tagcrumbs 0.3.1

data/lib/tagcrumbs/validations.rb

@@ -0,0 +1,301 @@
+module Tagcrumbs
+  class ResourceInvalid# < ClientError  #:nodoc:
+  end
+  
+  # == Borrowed from ActiveResource
+  
+  # Active Resource validation is reported to and from this object, which is used by Base#save
+  # to determine whether the object in a valid state to be saved. See usage example in Validations.  
+  class Errors
+    include Enumerable
+    attr_reader :errors
+
+    delegate :empty?, :to => :errors
+    
+    def initialize(base) # :nodoc:
+      @base, @errors = base, {}
+    end
+
+    # Add an error to the base Active Resource object rather than an attribute.
+    #
+    # ==== Examples
+    #   my_folder = Folder.find(1)
+    #   my_folder.errors.add_to_base("You can't edit an existing folder")
+    #   my_folder.errors.on_base
+    #   # => "You can't edit an existing folder"
+    #
+    #   my_folder.errors.add_to_base("This folder has been tagged as frozen")
+    #   my_folder.valid?
+    #   # => false
+    #   my_folder.errors.on_base
+    #   # => ["You can't edit an existing folder", "This folder has been tagged as frozen"]
+    #
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    # Adds an error to an Active Resource object's attribute (named for the +attribute+ parameter)
+    # with the error message in +msg+.
+    #
+    # ==== Examples
+    #   my_resource = Node.find(1)
+    #   my_resource.errors.add('name', 'can not be "base"') if my_resource.name == 'base'
+    #   my_resource.errors.on('name')
+    #   # => 'can not be "base"!'
+    #
+    #   my_resource.errors.add('desc', 'can not be blank') if my_resource.desc == ''
+    #   my_resource.valid?
+    #   # => false
+    #   my_resource.errors.on('desc')
+    #   # => 'can not be blank!'
+    #
+    def add(attribute, msg)
+      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
+      @errors[attribute.to_s] << msg
+    end
+
+    # Returns true if the specified +attribute+ has errors associated with it.
+    #
+    # ==== Examples
+    #   my_resource = Disk.find(1)
+    #   my_resource.errors.add('location', 'must be Main') unless my_resource.location == 'Main'
+    #   my_resource.errors.on('location')
+    #   # => 'must be Main!'
+    #
+    #   my_resource.errors.invalid?('location')
+    #   # => true
+    #   my_resource.errors.invalid?('name')
+    #   # => false
+    def invalid?(attribute)
+      !@errors[attribute.to_s].nil?
+    end
+
+    # A method to return the errors associated with +attribute+, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.on('login')
+    #   # => nil
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.on('login')
+    #   # => 'can not be empty'
+    #
+    #   my_person.errors.add('login', 'can not be longer than 10 characters') if my_person.login.length > 10
+    #   my_person.errors.on('login')
+    #   # => ['can not be empty', 'can not be longer than 10 characters']
+    def on(attribute)
+      errors = @errors[attribute.to_s]
+      return nil if errors.nil?
+      errors.size == 1 ? errors.first : errors
+    end
+    
+    alias :[] :on
+
+    # A method to return errors assigned to +base+ object through add_to_base, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_account = Account.find(1)
+    #   my_account.errors.on_base
+    #   # => nil
+    #
+    #   my_account.errors.add_to_base("This account is frozen")
+    #   my_account.errors.on_base
+    #   # => "This account is frozen"
+    #
+    #   my_account.errors.add_to_base("This account has been closed")
+    #   my_account.errors.on_base
+    #   # => ["This account is frozen", "This account has been closed"]
+    #
+    def on_base
+      on(:base)
+    end
+
+    # Yields each attribute and associated message per error added.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each {|attr, msg| messages += attr.to_s.humanize + " " + msg + "<br />"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
+    # through iteration as "First name can't be empty".
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each_full {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each_full
+      full_messages.each { |msg| yield msg }
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.full_messages.each {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def full_messages
+      full_messages = []
+
+      @errors.each_key do |attr|
+        @errors[attr].each do |msg|
+          next if msg.nil?
+
+          if attr == "base"
+            full_messages << msg
+          else
+            full_messages << [attr.to_s.humanize, msg].join(' ')
+          end
+        end
+      end
+      full_messages
+    end
+
+    def clear
+      @errors = {}
+    end
+
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
+    # with this as well.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.size
+    #   # => 0
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   my_person.error.size
+    #   # => 2
+    #
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+    
+    def from_format(document, format)
+      case format
+        when :xml:  from_xml(document)
+        when :json: from_json(document)
+      end
+    end
+    
+    # Grabs errors from the XML response.
+    def from_xml(xml)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.to_s.humanize => attr_name) }
+      messages = ::Array.wrap(Hash.from_xml(xml)['errors']['error']) rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+    
+    # Grabs errors from the JSON response.
+    # Added for Tagcrumbs
+    def from_json(json)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.to_s.humanize => attr_name) }
+
+      messages = JSON.parse(json)['errors']['error'] rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+  end
+  
+  # Module to support validation and errors with Active Resource objects. The module overrides
+  # Base#save to rescue ActiveResource::ResourceInvalid exceptions and parse the errors returned 
+  # in the web service response. The module also adds an +errors+ collection that mimics the interface 
+  # of the errors provided by ActiveRecord::Errors.
+  #
+  # ==== Example
+  #
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a 
+  # <tt>validates_presence_of :first_name, :last_name</tt> declaration in the model:
+  #
+  #   person = Person.new(:first_name => "Jim", :last_name => "")
+  #   person.save                   # => false (server returns an HTTP 422 status code and errors)
+  #   person.valid?                 # => false
+  #   person.errors.empty?          # => false
+  #   person.errors.count           # => 1
+  #   person.errors.full_messages   # => ["Last name can't be empty"]
+  #   person.errors.on(:last_name)  # => "can't be empty"
+  #   person.last_name = "Halpert"  
+  #   person.save                   # => true (and person is now saved to the remote service)
+  #
+  module Validations
+    # def self.included(base) # :nodoc:
+    #   base.class_eval do
+    #     alias_method_chain :save, :validation
+    #   end
+    # end
+    # 
+    # # Validate a resource and save (POST) it to the remote web service.
+    # def save_with_validation
+    #   save_without_validation
+    #   true
+    # rescue ResourceInvalid => error
+    #   errors.from_xml(error.response.body)
+    #   false
+    # end
+
+    # Checks for errors on an object (i.e., is resource.errors empty?).
+    # 
+    # ==== Examples
+    #   my_person = Person.create(params[:person])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    def valid?
+      errors.empty?
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end

data/lib/tagcrumbs.rb

@@ -0,0 +1,232 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+#require 'ruby-debug'
+
+gem 'activesupport', '2.3.2'
+require 'active_support' 
+
+gem 'hpricot', '0.8.1'
+require 'hpricot'
+
+gem 'htmlentities', '4.0.0'
+require 'htmlentities'
+
+gem 'json', '1.1.6'
+require 'JSON'
+
+gem 'oauth', '0.3.4'
+require 'oauth'
+
+gem 'mime-types', '1.16'
+require 'mime/types'
+
+gem 'builder', '2.1.2'
+require 'builder'
+
+# Inflections must be available before classes are loaded, needed to automatically find the correct classes
+ActiveSupport::Inflector.inflections do |inflect|
+ inflect.irregular 'address', 'address'
+ inflect.uncountable "settings"
+ inflect.uncountable "suggestions"
+end
+
+require 'tagcrumbs/validations'
+require 'tagcrumbs/config_store'
+require 'tagcrumbs/exceptions'
+
+# parsers
+require 'tagcrumbs/parsers/parser'
+require 'tagcrumbs/parsers/json_parser'
+require 'tagcrumbs/parsers/xml_parser'
+
+# builders
+require 'tagcrumbs/builders/builder'
+require 'tagcrumbs/builders/json_builder'
+require 'tagcrumbs/builders/xml_builder'
+
+# general
+require 'tagcrumbs/node'
+require 'tagcrumbs/requestor'
+require 'tagcrumbs/proxy'
+
+# resources
+require 'tagcrumbs/resources/resource'
+require 'tagcrumbs/resources/array'
+
+# models
+require 'tagcrumbs/resources/models/accessors'
+require 'tagcrumbs/resources/models/model'
+require 'tagcrumbs/resources/models/tagcrumb'
+require 'tagcrumbs/resources/models/place'
+
+require 'tagcrumbs/resources/models/address'
+require 'tagcrumbs/resources/models/activity'
+require 'tagcrumbs/resources/models/city'
+require 'tagcrumbs/resources/models/comment'
+require 'tagcrumbs/resources/models/country'
+require 'tagcrumbs/resources/models/fanship'
+require 'tagcrumbs/resources/models/favorite'
+require 'tagcrumbs/resources/models/filter'
+require 'tagcrumbs/resources/models/flag'
+require 'tagcrumbs/resources/models/friendship'
+require 'tagcrumbs/resources/models/geoname'
+require 'tagcrumbs/resources/models/link'
+require 'tagcrumbs/resources/models/location'
+require 'tagcrumbs/resources/models/picture'
+require 'tagcrumbs/resources/models/placemark'
+require 'tagcrumbs/resources/models/profile'
+require 'tagcrumbs/resources/models/profile_link'
+require 'tagcrumbs/resources/models/root'
+require 'tagcrumbs/resources/models/settings'
+require 'tagcrumbs/resources/models/state'
+require 'tagcrumbs/resources/models/subscription'
+require 'tagcrumbs/resources/models/suggestions'
+require 'tagcrumbs/resources/models/tag'
+require 'tagcrumbs/resources/models/user'
+require 'tagcrumbs/resources/models/user_recommendation'
+
+
+module Tagcrumbs  
+  VERSION = '0.3.1'
+  
+  class << self
+    # Returns the default configuration options of the gem. You can overwrite the options with configure
+    def default_options
+  		{
+  			:consumer_token => 'ZQAR3nW5D3S5JgU8EAKEfA',
+  			:consumer_secret => 'vMc7NA77eraJc9TwyImshEEMVgrEy4C8YURVlwoyrHE',
+  			:format => :xml,
+  			:consumer_options => 
+  			  {
+            :site => 'http://www.tagcrumbs.com'
+            #:site => 'http://localhost:2999'
+  			  }
+  		}
+  	end
+  	
+  	# Returns the current configuration options
+  	def options
+  		@@options ||= default_options.with_indifferent_access
+  	end
+  	
+  	# Resets the configuration options to the default_options
+  	def reset_options!
+  	  @@options = default_options.with_indifferent_access
+  	end
+
+    # Overwrite the default_options with your own options. You can specify:
+    # 
+    # consumer_secret:: The OAuth consumer secret of your client that you registered on www.tagcrumbs.com
+    # consumer_token:: The OAuth consumer token of your client that you registered on www.tagcrumbs.com
+    # consumer_options:: Further Options that will be passed to the OAuth Gem
+    # request_token:: The OAuth request token that you received that you can exchange against an access token
+    # request_secret:: The OAuth request secret that you received that you can exchange against an access token
+    # format:: The Tagcrumbs webservice supports XML and JSON. You can specify the format of your requests here
+  	def configure(new_options={})
+  	  new_options.symbolize_keys!
+  		new_options.assert_valid_keys(:consumer_secret, :consumer_token, :consumer_options, 
+  		                          :access_token, :access_secret, 
+  		                          :request_token, :request_secret,
+  		                          :format)
+  		                          
+  		self.options.merge!(new_options)
+  	end
+  	
+
+  	# A request_token that you can let the user authorize, alternatively you can directly use the authorize_url
+  	def request_token
+  	  return @@request_token if defined?(@@request_token)
+  	  @@request_token = Requestor.new.request_token
+  	  
+  	  options[:request_token]  = @@request_token.token
+  	  options[:request_secret] = @@request_token.secret
+  	  
+  	  @@request_token
+  	end
+  	
+  	# An URL that you should redirect the user to or that you should open in a browser on which the user has to approve access
+  	# for your application
+  	def authorize_url
+  	  request_token.authorize_url  	  
+  	end
+  	
+  	# After you redirected the user to the authorize_url and after the user authorized your application you can exchange 
+  	# the request_token against an access_token that you can use to make all further signed requests.
+  	# You should use configure to pass in your access_token and access_secret for all further web service calls.
+  	def exchange_request_token!
+  	  return @@access_token if defined?(@@access_token)
+  	  @@access_token = request_token.get_access_token
+  	  
+  	  options[:access_token]  = @@access_token.token
+  	  options[:access_secret] = @@access_token.secret
+  	  
+  	  @@access_token
+	  rescue OAuth::Unauthorized
+	    nil
+  	end
+  	
+  	# Returns the current user that approved the application and owns the current access_token
+  	# This is also used internally to automatically request all the URLs to POST new resources to.
+  	def current_user
+  	  @@current_user ||= User.load('/you')
+    end
+    
+    # Reads the index.(xml|json) file and automatically useses the URLs for further other queries
+    def root
+      @@root ||= Root.load('/index')
+    end
+  	
+  	# Constants that are used to validate query parameters in find and search queries
+  	def constants
+  	  @@constants ||= {
+  	    :per_page => [1, 5, 7, 10, 25, 50, 100],
+  	    :from => [:you, :friends, :fans, :recommendations, :everybody, :user],
+  	    :tagcrumb_type => ['Placemark', 'Favorite'],
+  	    :within => [0.015, 0.15, 0.55],
+  	    :sort => [:date, :distance, :name, :favorites, :comments],
+  	    :order => [:asc, :desc],
+  	    :w => [:unknown, :country, :state, :city, :zip, :street, :intersection, :address, :premise, :nearby, :everywhere]        
+  	  }.with_indifferent_access
+	  end
+	  
+	  # Validate that key has a valid value. Returns an error if it does not. The constants method returns the valid values.
+	  def validate(key, value)
+      if constants[key]
+        raise ArgumentError.new("#{key} must be one of the following: #{constants[key].join(', ')}") unless constants[key].include?(value)
+        true
+      end
+    end
+	  
+	  # Returns a Tagcrumbs Class by name
+  	def class_by_type(class_name)  	  
+  		"Tagcrumbs::#{class_name.classify}".constantize
+  	end
+  	
+  	# The supported formats of the Gem and their MIME types
+  	def supported_formats
+  	  {
+        :xml =>   ['application/xml',  'text/xml'],
+        :json =>  ['application/json', 'text/json']
+      }
+  	end
+    
+    # Checks whether there is a valid access_token and access_secret that can be used to make all further calls to the webservice.
+    def valid_credentials?
+      if options[:access_token] && options[:access_secret]
+        requestor = Requestor.new
+        requestor.get('/you')
+              
+        true
+      else
+        false
+      end
+    rescue Net::HTTPServerException => error      
+      requestor.response.code == '401' ? false : (raise error) # unauthorized
+    end
+  end
+  
+end
+
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/tagcrumbs.rb'}"
+puts "Loading tagcrumbs gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)