sheet_mapper 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sheet_mapper.gemspec
+gemspec

data/README.md

@@ -0,0 +1,55 @@
+# SheetMapper
+
+SheetMapper is about taking a google spreadsheet and converting a set of data rows into ruby objects.
+
+## Installation
+
+Setup in Gemfile:
+
+```ruby
+# Gemfile
+
+gem 'sheet_mapper'
+```
+
+and then `require 'sheet_mapper'` and you are done!
+
+## Usage
+
+First, define yourself an object mapper:
+
+```ruby
+class SomeMapper < SheetMapper::Base
+  # Defines each column for a row and maps each column to an attribute
+  columns :foo, :bar, :baz
+
+  # Defines the condition for a row to be considered valid
+  def valid_row?
+    self[:foo].present?
+  end
+
+  # Convert is_notable column to a boolean from raw string
+  # Any methods named after a column will override the default value
+  def is_notable
+    !!self[:bar].match(/true/i)
+  end
+end
+```
+
+This describes the column mappings and transformations to turn a spreadsheet row into a ruby object. Then you can use
+a mapper within a worksheet collection:
+
+```ruby
+sheet = SheetMapper::Worksheet.new(:mapper => SomeMapper, :key => 'k', :login => 'u', :password => 'p')
+collection = sheet.find_collection_by_title('title')
+records = collection.each do |record|
+  p record.attributes
+  # => { :foo => "...", :bar => false, ... }
+end
+```
+
+You can then work with the objects within the collection and access their attributes.
+
+## Contributors
+
+SheetMapper was created by [Nathan Esquenazi](http://github.com/nesquena) at Miso in 2012.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*_test.rb'
+  test.ruby_opts = ['-rubygems']
+end

data/example.rb

@@ -0,0 +1,53 @@
+=begin
+
+ class BubbleMapper < SheetMapper::Base
+   attributes :offset_seconds, :body, :link_url, :category
+ end
+
+ sheet = SheetMapper::Worksheet.new(:mapper => BubbleMapper, :key => 'sheet_key', :login => 'user', :password => 'pass')
+ collection = sheet.find_collection_by_title('title')
+ bubbles = collection.each do |bubble|
+   p bubble.to_hash
+ end
+
+=end
+
+require 'rubygems'
+require 'active_support/all'
+require 'google_spreadsheet'
+require File.expand_path('lib/sheet_mapper')
+
+class BubbleMapper < SheetMapper::Base
+  columns :offset_seconds, :is_notable, :category, :body, :image_url, :link_text, :link_url
+
+  def valid_row?
+    self[:body].present? && @pos > 7
+  end
+
+  def offset_seconds
+    return unless self[:offset_seconds].strip =~ /^[\d\:]+$/ # Only return offset if valid digits
+    offset = self[:offset_seconds].strip.split(':')
+    (offset[0].to_i * 60) + offset[1].to_i
+  end
+
+  # Convert is_notable to boolean
+  def is_notable
+    self[:is_notable].to_s.match(/true/i).present?
+  end
+end
+
+sheet = SheetMapper::Spreadsheet.new(:mapper => BubbleMapper, :key => ENV['SHEET_KEY'], :login => ENV['SHEET_LOGIN'], :password => ENV['SHEET_PASS'])
+collection = sheet.find_collection_by_title('s2e5')
+
+media_id        = collection.cell(2, 2)
+season_num      = collection.cell(3, 2)
+episode_num     = collection.cell(4, 2)
+user_id         = collection.cell(5, 2)
+duration        = collection.cell(6, 2)
+
+puts "Media: #{media_id}, User: #{user_id}"
+
+bubbles = collection.each do |bubble|
+  p bubble.attributes
+end
+

data/example2.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'active_support/all'
+require 'google_spreadsheet'
+require File.expand_path('lib/sheet_mapper')
+
+class GradeMapper < SheetMapper::Base
+  columns :topic, :grade, :score
+
+  def valid_row?
+    self[:topic].present? && @pos > 3
+  end
+
+  # Convert is_notable to boolean
+  def score
+    self[:score].to_i
+  end
+end
+
+sheet = SheetMapper::Spreadsheet.new(:mapper => GradeMapper, :key => ENV['SHEET_KEY'], :login => ENV['SHEET_LOGIN'], :password => ENV['SHEET_PASS'])
+collection = sheet.find_collection_by_title('data')
+
+name        = collection.cell(1, 2)
+age         = collection.cell(2, 2)
+
+puts "Name: #{name}, Age: #{age}"
+
+bubbles = collection.each do |bubble|
+  p bubble.attributes
+end
+

data/lib/core_ext/hash_ext.rb

@@ -0,0 +1,234 @@
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+
+
+  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method will be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # desirable.
+  #
+  #   b = {:b => 1}
+  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
+  #
+  alias nested_under_indifferent_access with_indifferent_access
+end
+
+
+# This class has dubious semantics and we only have it so that
+# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
+# and they get the same value for both keys.
+
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+
+    # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      self.class.new(self).tap do |new_hash|
+        new_hash.default = default
+      end
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    undef :symbolize_keys!
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        if value.is_a? Hash
+          value.nested_under_indifferent_access
+        elsif value.is_a?(Array)
+          value.dup.replace(value.map { |e| convert_value(e) })
+        else
+          value
+        end
+      end
+  end
+end
+
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/lib/core_ext/object_ext.rb

@@ -0,0 +1,114 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are all blank.
+  #
+  # This simplifies:
+  #
+  #   if address.nil? || address.empty?
+  #
+  # ...to:
+  #
+  #   if address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not <tt>blank?</tt>.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all. For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   {:key => 'value'}.blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class String
+  # 0x3000: fullwidth whitespace
+  NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   "".blank?                 # => true
+  #   "   ".blank?              # => true
+  #   "　".blank?               # => true
+  #   " something here ".blank? # => false
+  #
+  def blank?
+    # 1.8 does not takes [:space:] properly
+    self !~ NON_WHITESPACE_REGEXP
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  def blank?
+    false
+  end
+end

data/lib/sheet_mapper.rb

@@ -0,0 +1,13 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'core_ext/hash_ext'   unless Hash.method_defined?(:symbolize_keys)
+require 'core_ext/object_ext' unless Object.method_defined?(:present?)
+require 'google_spreadsheet'
+require 'sheet_mapper/version'
+require 'sheet_mapper/collection'
+require 'sheet_mapper/spreadsheet'
+require 'sheet_mapper/base'
+
+module SheetMapper
+
+end

data/lib/sheet_mapper/base.rb

@@ -0,0 +1,79 @@
+module SheetMapper
+  class Base
+
+    # SheetMapper::Base.new(0, ["foo", "bar"])
+    def initialize(pos, data=[])
+      @pos    = pos
+      @data   = data
+      @attrs  = process_data
+    end
+
+    # columns :offset_seconds, :body, :link_url, :category
+    def self.columns(*names)
+      names.any? ? @columns = names : @columns
+    end
+
+    # Returns the spreadsheet as a hash
+    def attributes
+      result = HashWithIndifferentAccess.new
+      @attrs.each do |name, val|
+        result[name] = self.respond_to?(name) ? self.send(name) : val
+      end
+      result
+    end
+
+    # Returns an attribute value
+    # @record[:attr_name]
+    def [](name)
+      @attrs[name]
+    end
+
+    # Assign an attribute value
+    # @record[:attr_name]
+    def []=(name, val)
+      @attrs[name] = val
+    end
+
+    # Returns true if the row is a valid record
+    def valid_row?
+      true
+    end
+
+    protected
+
+    # column_order => [:offset_seconds, :body, :link_url, :category]
+    def column_order
+      self.class.columns
+    end
+
+    # column_pos(:offset_seconds) => 1
+    # column_pos(:body) => 4
+    def column_pos(name)
+      self.column_order.index(name)
+    end
+
+    def log(text, newline=true)
+      output = newline ? method(:puts) : method(:print)
+      output.call(text) if LOG
+    end # log
+
+    # Process all columns into an attribute hash
+    def process_data
+      m = HashWithIndifferentAccess.new
+      column_order.each { |name| m[name.to_s] = self.attribute_value(name) }
+      m
+    end
+
+    # attribute_value(:body, 1, 1) => "Foo"
+    # attribute_value(:image_url, 1, 3) => nil
+    # attribute_value(:link_text, 2) => "Article"
+    # Create a method "format_<name>" to transform the column value (or pass the value directly)
+    # Column position defaults to matching named column in `column_order`
+    def attribute_value(name)
+      val = @data[column_pos(name)]
+      val = val.to_i if val && name.to_s =~ /_(id|num)/
+      val
+    end
+
+  end
+end

data/lib/sheet_mapper/collection.rb

@@ -0,0 +1,47 @@
+module SheetMapper
+  class CollectionNotFound < StandardError; end
+
+  class Collection
+    attr_reader :records, :worksheet
+
+    # spreadsheet is a SheetMapper::Spreadsheet
+    # SheetMapper::Collection.new(@sheet, @work)
+    def initialize(spreadsheet, worksheet)
+      @spreadsheet = spreadsheet
+      @worksheet   = worksheet
+      @mapper      = @spreadsheet.mapper
+      @records     = process_records!
+    end
+
+    # Each block for every mapped record
+    # @collection.each { |m| ...mapped obj... }
+    def each(&block)
+      records.each(&block)
+    end
+
+    # Returns an array of mapped records
+    # @collection.rows => [<SheetMapper::Base>, ...]
+    def rows
+      @worksheet.rows
+    end
+
+    # Returns raw value from worksheet cell
+    # @collection.cell(4, 5) => "Bob"
+    def cell(row, col)
+      @worksheet[row, col]
+    end
+
+    protected
+
+    # Converts all valid raw data hashes into mapped records
+    # process_records! => [<SheetMapper::Base>, ...]
+    def process_records!
+      records = []
+      @worksheet.rows.each_with_index do |record, index|
+        record = @mapper.new(index, record)
+        records << record if record.valid_row?
+      end
+      records
+    end
+  end
+end

data/lib/sheet_mapper/spreadsheet.rb

@@ -0,0 +1,21 @@
+module SheetMapper
+  class Spreadsheet
+    attr_reader :mapper, :session, :spreadsheet
+
+    # SheetMapper::Worksheet.new(:mapper => SomeMapper, :key => 'sheet_key', :login => 'user', :password => 'pass')
+    def initialize(options={})
+      @mapper   = options[:mapper]
+      @session = ::GoogleSpreadsheet.login(options[:login], options[:password])
+      @spreadsheet = @session.spreadsheet_by_key(options[:key])
+    end
+
+    # Returns the first worksheet with given title
+    # sheet.find_collection_by_title('title') => <SheetMapper::Collection>
+    def find_collection_by_title(val)
+      val_pattern = /#{val.to_s.downcase.gsub(/\s/, '')}/
+      worksheet = self.spreadsheet.worksheets.find { |w| w.title.downcase.gsub(/\s/, '') =~ val_pattern }
+      raise CollectionNotFound, "No worksheet found '#{val}'! Please try again." unless worksheet
+      Collection.new(self, worksheet)
+    end
+  end
+end

data/lib/sheet_mapper/version.rb

@@ -0,0 +1,3 @@
+module SheetMapper
+  VERSION = "0.0.1"
+end

data/sheet_mapper.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sheet_mapper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sheet_mapper"
+  s.version     = SheetMapper::VERSION
+  s.authors     = ["Nathan Esquenazi"]
+  s.email       = ["nesquena@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Map google spreadsheets to ruby objects}
+  s.description = %q{Map google spreadsheets to ruby objects.}
+
+  s.rubyforge_project = "sheet_mapper"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'google-spreadsheet-ruby', '~> 0.2.1'
+
+  s.add_development_dependency 'minitest', "~> 2.11.0"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'fakeweb'
+  s.add_development_dependency 'awesome_print'
+end

data/test/base_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../test_config.rb', __FILE__)
+
+class TestBase < SheetMapper::Base
+  columns :name, :age, :color
+
+  def age
+    self[:age] * 2
+  end
+
+  def name
+    self[:name].upcase
+  end
+end
+
+describe "Base" do
+  setup do
+    @data = ["Bob", 21, "Red"]
+  end
+
+  should "support columns accessor" do
+    assert_equal [:name, :age, :color], TestBase.columns
+  end
+
+  context "for attributes method" do
+    setup do
+      @test = TestBase.new(1, @data)
+    end
+
+    should "return attribute hash" do
+      assert_equal "BOB", @test.name
+      assert_equal 42, @test.age
+      assert_equal "Red", @test[:color]
+    end
+  end # attributes
+
+  context "for accessing attribute" do
+    setup do
+      @test = TestBase.new(1, @data)
+    end
+
+    should "return value of attribute" do
+      assert_equal "Bob", @test[:name]
+    end
+  end # access []
+
+  context "for assigning attributes" do
+    setup do
+      @test = TestBase.new(1, @data)
+      @test[:age] = 45
+    end
+
+    should "have new value assigned" do
+      assert_equal 45, @test[:age]
+    end
+  end # assign []=
+end # Base

data/test/collection_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../test_config.rb', __FILE__)
+
+class TestMapper
+  attr_reader :index, :record
+
+  def initialize(index, record)
+    @index  = index
+    @record = record
+  end
+
+  def tuple; [name, age]; end
+  def name; record[:name]; end
+  def age;  record[:age]; end
+  def valid_row?; true; end
+end # TestMapper
+
+describe "Collection" do
+  setup do
+    @worksheet   = stub(:rows => [{ :name => "Bob", :age => 21 }, { :name => "Susan", :age => 34 }, { :name => "Joey", :age => 67 }])
+    @spreadsheet = stub(:mapper => TestMapper)
+  end
+
+  context "for worksheet accessor" do
+    setup do
+      @collection = SheetMapper::Collection.new(@spreadsheet, @worksheet)
+    end
+
+    should "return worksheet from accessor" do
+      assert_equal @worksheet, @collection.worksheet
+    end
+  end # worksheet
+
+  context "for each method" do
+    setup do
+      @collection = SheetMapper::Collection.new(@spreadsheet, @worksheet)
+    end
+
+    should "support iterating each mapped row" do
+      rows = []
+      @collection.each { |c| rows << c }
+      assert_equal 3, rows.size
+      assert_equal ["Bob", 21], rows[0].tuple
+      assert_equal ["Susan", 34], rows[1].tuple
+      assert_equal ["Joey", 67], rows[2].tuple
+    end
+  end # each
+
+  context "for rows method" do
+    setup do
+      @collection = SheetMapper::Collection.new(@spreadsheet, @worksheet)
+    end
+
+    should "return raw data hashes" do
+      rows = @collection.rows
+      assert_equal ["Bob", 21], [rows[0][:name], rows[0][:age]]
+      assert_equal ["Susan", 34], [rows[1][:name], rows[1][:age]]
+      assert_equal ["Joey", 67], [rows[2][:name], rows[2][:age]]
+    end
+  end # rows
+
+  context "for cell method" do
+    setup do
+      @worksheet.expects(:[]).with(4,5).returns("foo")
+      @collection = SheetMapper::Collection.new(@spreadsheet, @worksheet)
+    end
+
+    should "return raw data in worksheet" do
+      assert_equal "foo", @collection.cell(4,5)
+    end
+  end # cell
+
+  context "for records method" do
+    setup do
+      @collection = SheetMapper::Collection.new(@spreadsheet, @worksheet)
+    end
+
+    should "support iterating each mapped row" do
+      rows = @collection.records
+      assert_equal 3, rows.size
+      assert_equal ["Bob", 21], rows[0].tuple
+      assert_equal ["Susan", 34], rows[1].tuple
+      assert_equal ["Joey", 67], rows[2].tuple
+    end
+  end # records
+end

data/test/spreadsheet_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../test_config.rb', __FILE__)
+
+describe "Spreadsheet" do
+  setup do
+    @sheet_stub = stub(:sheet)
+    @session_stub = stub(:session)
+    @session_stub.expects(:spreadsheet_by_key).with('foo').returns(@sheet_stub)
+    ::GoogleSpreadsheet.expects(:login).with('login', 'pass').returns(@session_stub)
+  end
+
+  context "for initialize" do
+    setup do
+      @sheet = SheetMapper::Spreadsheet.new(:mapper => Object, :key => 'foo', :login => 'login', :password => 'pass')
+    end
+
+    should "return spreadsheet class" do
+      assert_kind_of SheetMapper::Spreadsheet, @sheet
+    end
+
+    should "have access to readers" do
+      assert_equal Object, @sheet.mapper
+      assert_equal @session_stub, @sheet.session
+      assert_equal @sheet_stub, @sheet.spreadsheet
+    end
+  end # initialize
+
+  context "for find_collection_by_title method" do
+    setup do
+      @sheet = SheetMapper::Spreadsheet.new(:mapper => Object, :key => 'foo', :login => 'login', :password => 'pass')
+      @work_stub = stub(:worksheet)
+      @work_stub.expects(:title).returns("FOO")
+      @work_stub.expects(:rows).returns([])
+      @sheet_stub.expects(:worksheets).returns([@work_stub])
+      @collection = @sheet.find_collection_by_title("foo")
+    end
+
+    should "return the expected collection" do
+      assert_kind_of SheetMapper::Collection, @collection
+      assert_equal @work_stub, @collection.worksheet
+    end
+  end # find_collection_by_title
+end # Spreadsheet

data/test/test_config.rb

@@ -0,0 +1,12 @@
+require 'minitest/autorun'
+require 'mocha'
+require 'fakeweb'
+require 'ap'
+require File.expand_path('../../lib/sheet_mapper', __FILE__)
+
+Dir[File.expand_path("../test_helpers/*.rb", __FILE__)].each { |f| require f }
+FakeWeb.allow_net_connect = false
+
+class MiniTest::Unit::TestCase
+  include Mocha::API
+end

data/test/test_helpers/mini_shoulda.rb

@@ -0,0 +1,84 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'mocha' # Load mocha after minitest
+
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+class MiniTest::Spec
+  class << self
+    alias :setup :before unless defined?(Rails)
+    alias :teardown :after unless defined?(Rails)
+    alias :should :it
+    alias :context :describe
+    def should_eventually(desc)
+      it("should eventually #{desc}") { skip("Should eventually #{desc}") }
+    end
+  end
+  alias :assert_no_match  :refute_match
+  alias :assert_not_nil   :refute_nil
+  alias :assert_not_equal :refute_equal
+
+  # assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+  def assert_same_elements(a1, a2, msg = nil)
+    [:select, :inject, :size].each do |m|
+      [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+    end
+
+    assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
+    assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }
+
+    assert_equal(a1h, a2h, msg)
+  end
+
+  #   assert_contains(['a', '1'], /\d/) => passes
+  #   assert_contains(['a', '1'], 'a') => passes
+  #   assert_contains(['a', '1'], /not there/) => fails
+  def assert_contains(collection, x, extra_msg = "")
+    collection = [collection] unless collection.is_a?(Array)
+    msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+    case x
+    when Regexp
+      assert(collection.detect { |e| e =~ x }, msg)
+    else
+      assert(collection.include?(x), msg)
+    end
+  end
+
+  # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+  # none of the elements from the collection match x.
+  def assert_does_not_contain(collection, x, extra_msg = "")
+    collection = [collection] unless collection.is_a?(Array)
+    msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+    case x
+    when Regexp
+      assert(!collection.detect { |e| e =~ x }, msg)
+    else
+      assert(!collection.include?(x), msg)
+    end
+  end
+end # MiniTest::Spec
+
+class ColoredIO
+  def initialize(io)
+    @io = io
+  end
+
+  def print(o)
+    case o
+    when "." then @io.send(:print, o.green)
+    when "E" then @io.send(:print, o.yellow)
+    when "F" then @io.send(:print, o.red)
+    when "S" then @io.send(:print, o.magenta)
+    else @io.send(:print, o)
+    end
+  end
+
+  def puts(*o)
+    super
+  end
+end
+
+MiniTest::Unit.output = ColoredIO.new(MiniTest::Unit.output)

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification 
+name: sheet_mapper
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Esquenazi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: google-spreadsheet-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: awesome_print
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Map google spreadsheets to ruby objects.
+email: 
+- nesquena@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- example.rb
+- example2.rb
+- lib/core_ext/hash_ext.rb
+- lib/core_ext/object_ext.rb
+- lib/sheet_mapper.rb
+- lib/sheet_mapper/base.rb
+- lib/sheet_mapper/collection.rb
+- lib/sheet_mapper/spreadsheet.rb
+- lib/sheet_mapper/version.rb
+- sheet_mapper.gemspec
+- test/base_test.rb
+- test/collection_test.rb
+- test/spreadsheet_test.rb
+- test/test_config.rb
+- test/test_helpers/mini_shoulda.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: sheet_mapper
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Map google spreadsheets to ruby objects
+test_files: 
+- test/base_test.rb
+- test/collection_test.rb
+- test/spreadsheet_test.rb
+- test/test_config.rb
+- test/test_helpers/mini_shoulda.rb