tagcrumbs 0.3.1

data/examples/user_recommendation_new.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby -rubygems
+
+require File.dirname(__FILE__) + '/request_authorization'
+
+placemark = Tagcrumbs.current_user.placemarks.first
+friend = Tagcrumbs.current_user.friends.first
+
+recommendation = Tagcrumbs::UserRecommendation.new(:placemark => placemark, :recommended_user => friend, :message => 'very interesting place, check it out!')
+
+if recommendation.save
+  puts "You sent a recommendation to #{friend}!"
+else
+  puts "Could not sent a recommendation to #{friend}!"
+  puts recommendation.errors.full_messages.join("\n")
+end

data/lib/tagcrumbs/builders/builder.rb

@@ -0,0 +1,45 @@
+module Tagcrumbs
+  class Builder
+    attr_accessor :model
+    
+    def initialize(model, options={})
+      self.model = model
+    end
+    
+    def build
+      ''
+    end
+    
+    # also include the name as we might have some exceptions based on name someday
+    def typecast(name, value)
+      if value.class == Time
+        value.iso8601
+      elsif value.is_a?(Tagcrumbs::Model)
+        value.resource_url
+      else
+        value
+      end
+    end
+    
+    # also include the name as we might have some exceptions based on name someday
+    def determine_type(name, value)
+      type = {}
+      type.merge!(:nil => true) if value.nil?
+
+      if value.class == Time
+        type.merge!(:type => :timestamp)
+      elsif value.class == TrueClass || value.class == FalseClass
+        type.merge!(:type => :boolean)
+      elsif value.class == Float
+        type.merge!(:type => :float)
+      elsif value.class == Fixnum
+        type.merge!(:type => :integer)
+      elsif value.is_a?(Tagcrumbs::Model)
+        type.merge!(:type => value.class_name)
+      end
+      
+      type
+    end
+    
+  end
+end

data/lib/tagcrumbs/builders/json_builder.rb

@@ -0,0 +1,38 @@
+module Tagcrumbs
+  class JsonBuilder < Builder
+    def build(options={})
+      options.reverse_merge!(:to_json => true)
+      
+      attributes = {}
+      
+      if options[:badgerfish] # build badgerfish style json
+        model.attributes(options).each do |key, value|
+          attributes[key] = {'$' => typecast(key, value)}.merge(badgerfish_attributes(determine_type(key, value)))
+        end
+      
+        hash = {model.class_name.underscore => attributes.merge(badgerfish_attributes(:type => model.class_name))}
+      else # build plain json
+        model.attributes(options).each do |key, value|
+          attributes[key] = typecast(key, value)
+        end
+        
+        hash = {model.class_name.underscore => attributes}
+      end
+      
+      options[:to_json] ? hash.to_json : hash # makes testing easier
+    end
+    
+    
+    private
+    
+      def badgerfish_attributes(attributes)
+        hash = {}
+        
+        attributes.each do |k, v|
+          hash["@#{k}"] = v
+        end
+        
+        hash
+      end
+  end
+end

data/lib/tagcrumbs/builders/xml_builder.rb

@@ -0,0 +1,30 @@
+module Tagcrumbs
+  class XmlBuilder < Builder
+    def build(options={})      
+      result = ''
+      
+      xml = ::Builder::XmlMarkup.new(:indent => 1, :target => result)
+      xml.instruct! :xml, :version => "1.0"
+      
+      xml.tag!(model.class_name.underscore, :type => model.class_name, 'xmlns:xlink' => "http://www.w3.org/1999/xlink") do
+        attributes = model.attributes(options)
+        attribute_keys = attributes.keys
+        attribute_keys.sort!{|a, b| a.to_s <=> b.to_s} if options[:sorted_attributes] # for testing, otherwise output order is random
+        
+        attribute_keys.each do |key|
+          if attributes[key].is_a?(Hash) # nested attributes like the address attributes on creation of a placemark   
+            xml.tag!(key) do
+              attributes[key].each do |k, v|
+                xml.tag!(k, typecast(k, v), determine_type(k, v))
+              end
+            end
+          else
+            xml.tag!(key, typecast(key, attributes[key]), determine_type(key, attributes[key]))
+          end
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/tagcrumbs/cli.rb

@@ -0,0 +1,268 @@
+require 'optparse' 
+require 'ostruct'
+require File.dirname(__FILE__) + '/../tagcrumbs'
+
+module Tagcrumbs
+  class CLI    
+    attr_reader :options, :stdout, :stdin
+    
+    def self.execute(stdout, stdin, stderr, arguments = [])
+      self.new.execute(stdout, stdin, stderr, arguments)
+    end
+
+    def initialize
+      @options = {}
+
+      trap(:INT) { exit } # no backtrace on ^C
+    end
+
+    def execute(stdout, stdin, stderr, arguments = [])
+      @stdout = stdout
+      @stdin  = stdin
+      @stderr = stderr
+      
+      @config_store = Tagcrumbs::ConfigStore.load(ENV['HOME'] + '/.tagcrumbs')
+      Tagcrumbs.configure(@config_store.options)
+      
+      if Tagcrumbs.valid_credentials?
+        if arguments.present?
+          option_parser.parse!(arguments)
+          execute_new_placemark
+        else
+          execute_interactive_mode
+        end
+      else
+        execute_authorize
+      end
+    end
+    
+    protected
+    
+      def option_parser
+        option_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: #{$0} [options]"
+          
+          @options[:placemark] = {}
+          @options[:placemark][:address_attributes] = {}
+          
+          opts.on('-v', '--version')  do 
+            output_version
+            exit 0
+          end
+          
+          # GENERAL OPTIONS
+          opts.on('-h', '--help') do
+           output_help
+           exit 0
+          end
+          
+          opts.on('-V', '--verbose') do
+            @options[:verbose] = true
+          end
+          
+          # PLACEMARK OPTIONS
+          opts.on("-n", "--name NAME", "Give your tagcrumb a name") do |name|
+            @options[:placemark][:name] = name
+          end
+           
+          opts.on("-N", "--notes NOTES", "Add some notes") do |notes| 
+            @options[:placemark][:notes] = notes
+          end
+            
+          opts.on("-t", "--tags tag1,tag2,tagX", "Add tags") do |tags| 
+            @options[:placemark][:tags] = tags
+          end
+          
+          opts.on("-y", "--latitude LATITUDE", Float, "Set the latitude") do |latitude|
+            @options[:placemark][:latitude] = latitude
+          end
+           
+          opts.on("-x", "--longitude LATITUDE", Float, "Set the longitude") do |longitude| 
+            @options[:placemark][:longitude] = longitude
+          end
+          
+          opts.on("-p", "--private", "Make it private") do
+            @options[:placemark][:private] = true
+          end
+          
+          opts.on("-g", "--guess-city", "Make a guess on the correct city") do
+            @options[:placemark][:guess_city] = true
+          end
+          
+          opts.on("-w", "--websites url1,url2,urlX", ::Array, "List of websites") do |links|
+            @options[:placemark][:links] = links
+          end
+          
+          
+          opts.on("--address-street STREET", "The street address") do |street| 
+            @options[:placemark][:address_attributes][:street] = street
+          end
+          
+          opts.on("--address-postal-code ZIP", "The postal code") do |postal_code| 
+            @options[:placemark][:address_attributes][:postal_code] = postal_code
+          end
+          
+          opts.on("--address-city CITY", "The city name as it will be put in the address") do |city| 
+            @options[:placemark][:address_attributes][:city] = city
+          end
+          
+          opts.on("--address-state STATE", "The state name as it will be put in the address") do |state| 
+            @options[:placemark][:address_attributes][:state] = state
+          end
+          
+          opts.on("--address-country COUNTRY", "The country name as it will be put in the address") do |country| 
+            @options[:placemark][:address_attributes][:country] = country
+          end
+          
+          opts.separator ""
+          opts.separator "Create a new placemark with command line arguments:"
+          opts.separator "#{$0} -n 'name of the tagcrumb' -x 9.012 -y 49.9"
+          opts.separator ""
+          opts.separator "Create a new placemark in interactive mode:"
+          opts.separator "#{$0}"
+        end
+      end
+      
+      def output_version
+        @stdout.puts "#{$0} version #{Tagcrumbs::VERSION}"
+      end
+      
+      def output_help
+        output_version
+        @stdout.puts
+        @stdout.puts option_parser.help
+      end
+      
+      def verbose_puts(msg)
+        @stdout.puts msg if @options[:verbose]
+      end
+      
+      def execute_authorize
+        @stdout.puts "Connecting to Tagcrumbs..."
+        
+        authorize_url = Tagcrumbs.authorize_url
+        %x(open #{authorize_url})
+
+        @stdout.print "Please authorize the application in your browser: #{authorize_url}.\nPress Enter after you authorized the application to continue..."
+        @stdin.gets
+        
+        if Tagcrumbs.exchange_request_token!        
+          @stdout.puts "The application is now authorized. You won't have to do this again the next time you run the application."
+          @config_store.update(Tagcrumbs.options.slice(:access_token, :access_secret))
+        else
+          @stdout.puts "The application could not be authorized."
+        end
+      end
+      
+      def execute_new_placemark        
+        links = @options[:placemark].delete(:links)
+        
+        placemark = Tagcrumbs::Placemark.new(@options[:placemark])
+
+        if placemark.save 
+          verbose_puts "Saved: " + placemark.resource_url
+            
+          if links.present?
+            links.each do |url|              
+              link = Tagcrumbs::Link.new(:url => url, :placemark => placemark)
+
+              if link.save
+                verbose_puts "Saved Link: " + link.resource_url
+              else
+                @stderr.puts "** Link Errors: \n"
+                @stderr.puts link.errors.full_messages.join("\n")
+              end
+            end
+          end 
+        else
+          @stderr.puts "** Placemark could not be created!"
+
+          @stderr.puts "** Placemark Errors: \n"          
+          @stderr.puts placemark.errors.full_messages.join("\n")
+        end # end placemark.save                                     
+      end
+      
+      def execute_interactive_mode
+        @stdout.puts "== Create a new Placemark on tagcrumbs.com"
+        @stdout.puts "You can also use arguments to create a placemark, type #{$0} -h to find out how.\n"
+        
+        begin
+          placemark = Tagcrumbs::Placemark.new
+        
+          @stdout.print "Latitude: "
+          placemark.latitude = @stdin.gets.chomp
+        
+          @stdout.print "Longitude: "
+          placemark.longitude = @stdin.gets.chomp
+
+          @stdout.print "\n== Loading suggestions... \n"
+          suggestions = placemark.suggestions
+        
+          if suggestions.names.present?
+            @stdout.puts "\n== Select a name"
+          
+            suggestions.names.each_with_index do |value, index|
+              @stdout.puts "   #{index+1}. #{value}"
+            end
+          
+            @stdout.puts "   0. Enter your own name"
+          
+            @stdout.print "Select a number: "
+            number = @stdin.gets.chomp
+          
+            if number.to_i == 0
+              @stdout.print "Enter a name: "
+              placemark.name = @stdin.gets.chomp
+            else
+              placemark.name = suggestions.names[number.to_i-1]
+            end
+          else
+            @stdout.puts "No suggestions found."
+            @stdout.print "Enter a name: "
+            placemark.name = @stdin.gets.chomp
+          end
+        
+          @stdout.puts "\n== Enter tags (comma separated)"
+        
+          @stdout.puts "Popular tags: #{suggestions.popular_tags.map{|t| t.name}.join(', ')}" if suggestions.popular_tags.present?
+          @stdout.puts "Recommended tags: #{suggestions.recommended_tags.map{|t| t.name}.join(', ')}" if suggestions.recommended_tags.present?
+          @stdout.print "Enter tags: "
+        
+          placemark.tag_list = @stdin.gets.chomp
+        
+          @stdout.print "\n== Enter notes: "
+          placemark.notes = @stdin.gets.chomp
+        
+        
+          if suggestions.cities.present?
+            @stdout.puts "\n== Which city?"
+          
+            suggestions.cities.each_with_index do |city, index|
+              @stdout.puts "   #{index+1}. #{city.name}"
+            end
+          
+            @stdout.puts "   0. Middle of Nowhere"
+            
+            @stdout.print "Select a city: "
+            number = @stdin.gets.chomp
+            placemark.city = (number == '0') ? nil : suggestions.cities[number.to_i-1]
+          end
+        
+          @stdout.print "== Save the placemark? (y/n): "
+          save = @stdin.gets.chomp
+        
+          if placemark.save
+            @stdout.puts "Saved (#{placemark.resource_url})"
+          else
+            @stdout.puts "Could not be saved:"
+            @stderr.puts placemark.errors.full_messages.join("\n")
+          end
+        
+          @stdout.print "== Create another placemark? (y/n): "
+          start_over = @stdin.gets.chomp
+        end while(start_over == 'y')
+        
+      end
+      
+  end
+end

data/lib/tagcrumbs/config_store.rb

@@ -0,0 +1,35 @@
+module Tagcrumbs
+  # Use the ConfigStore to save configuration options to a yaml file (tokens)
+  class ConfigStore
+    attr_accessor :filename, :options
+
+    def initialize(filename, options ={})      
+      @filename = filename
+      @options = options
+    end
+    
+    # Load a filename and read it with YAML
+    def self.load(filename)
+      config = File.exist?(filename) ? YAML::load(open(filename)) : {}
+      new(filename, config)
+    end
+    
+    # Update the current options and save the file
+    def update(c={})
+      @options.merge!(c)
+      save
+      self
+    end
+    
+    # Save the current options into the file in YAML format
+    def save
+      File.open(filename, 'w') { |f| f.write(YAML.dump(@options)) }
+      self
+    end
+  end
+  
+end
+
+
+
+

data/lib/tagcrumbs/exceptions.rb

@@ -0,0 +1,13 @@
+module Tagcrumbs  
+  class UnsupportedFormat < StandardError; end 
+  
+  class CreateURLMissing < StandardError; end
+  class ResourceURLMissing < StandardError; end
+  
+  class CreateImpossible  < StandardError; end
+  class UpdateImpossible  < StandardError; end  
+  class DestroyImpossible  < StandardError; end  
+  
+  class InvalidRequest < StandardError; end
+  
+end

data/lib/tagcrumbs/node.rb

@@ -0,0 +1,43 @@
+module Tagcrumbs
+  class Node
+    attr_accessor :name, :value
+    attr_writer :properties
+    
+    def initialize(name, value, properties={})
+      self.name = name
+      self.properties = properties
+      self.value = typecast_value(value)
+    end
+    
+    # The XML/JSON properties of a node, they are used to typecast the value and kept around 
+    # so that it is also possible to look at them later
+    def properties
+      @properties ||= {}
+    end
+    
+    private 
+      # typecast value depending on the properties that are set and read from the webservice
+      def typecast_value(value)
+        return nil if value.nil?
+        
+        if value.is_a?(String)        
+          if properties['nil'] == 'true'
+            nil
+          else
+            case properties['type']
+              when 'timestamp': value.to_time
+              when 'float': value.to_f
+              when 'integer': value.to_i
+              when 'boolean': value == 'true' ? true : false
+              else
+                coder = HTMLEntities.new
+                coder.decode(value)
+            end
+          end
+        else
+          value
+        end
+      end
+    
+  end
+end

data/lib/tagcrumbs/parsers/json_parser.rb

@@ -0,0 +1,79 @@
+module Tagcrumbs
+  # A parser for JSON
+  class JsonParser < Parser
+    attr_accessor :_name # save the name of the json hash
+    
+    def initialize(parser_or_document)
+      if parser_or_document.is_a?(String)
+        tmp = JSON.parse(parser_or_document)
+        self._name = tmp.keys.first
+        self.document = tmp[self._name]
+      elsif(parser_or_document.is_a?(Tagcrumbs::JsonParser))
+        self.document = parser_or_document.document
+      else
+        self.document = parser_or_document
+      end
+
+      self.format = :json
+    end
+    
+    # Get a node with a specific name from the document
+    def get_node(name)
+      self.document[name.to_s]
+    end
+    
+    # Is this a stub and therefore only a "link" in the webservice or is a resource loaded?
+    def node_loaded?
+      badgerfish_json_loaded?
+    end
+    
+    # Get all child nodes with a specific name
+    def nodes_with_name(name)      
+      self.document[name] || []
+    end
+    
+    # Get all attributes from the badgerfish JSON that (all keys starting with '@')
+    def get_attributes
+      attributes_from_badgerfish_json
+    end
+    
+    # Get one attribute from the JSON
+    def get_attribute(attribute)
+      self.document["@#{attribute}"]
+    end
+    
+    # Get the value of an element ('$' key in badgerfish JSON)
+    def get_value
+      self.document['$']
+    end
+    
+    # Get the name of the current element
+    def name
+      _name || self.document.keys.select{|k| k.first != '@'}.first
+    end
+    
+    private
+    
+      def attributes_from_badgerfish_json
+        hash = {}
+
+        self.document.each do |k, v|
+          if k.first == '@'
+            hash[k[1..-1]] = v
+          end
+        end
+
+        hash
+      end
+
+      # is there anything else besides badgerfish style attributes?
+      def badgerfish_json_loaded?         
+        self.document.each do |k, v|
+          return true if k.first != '@'
+        end
+
+        false
+      end    
+  
+  end
+end

data/lib/tagcrumbs/parsers/parser.rb

@@ -0,0 +1,24 @@
+module Tagcrumbs
+  # Parser is an abstract class that provides common functions for all parsers and that helps to get a correct parser for 
+  # a specific format
+  class Parser
+    attr_accessor :document, :format
+    
+    # Create a parser for a specific format (xml or json)
+    # +document_or_parser+ can either be a Parser or a document, if it is a Parser it will be returned as it is,
+    # otherwise a parser will be created out of the document
+    def self.new_for_format(document_or_parser, format)
+      if document_or_parser.is_a?(Tagcrumbs::Parser) # allow to also pass a document right into the method
+        document_or_parser
+      else
+        case format
+          when :xml:  XmlParser.new(document_or_parser)
+          when :json: JsonParser.new(document_or_parser)
+          else
+            raise UnsupportedFormat
+        end
+      end
+    end
+    
+  end
+end

data/lib/tagcrumbs/parsers/xml_parser.rb

@@ -0,0 +1,54 @@
+module Tagcrumbs
+  class XmlParser < Parser
+    
+    def initialize(parser_or_document)
+      if parser_or_document.is_a?(String)
+        xml = Hpricot.XML(parser_or_document)
+        self.document = xml.root ? xml.root : xml
+      elsif(parser_or_document.is_a?(Tagcrumbs::XmlParser))
+        self.document = parser_or_document.document
+      else
+        self.document = parser_or_document
+      end
+      
+      self.format = :xml
+    end
+    
+    # Get a node with a specific name from the document
+    def get_node(name)
+      self.document.children_of_type(name.to_s).first
+    end
+    
+    # Does the document contain a resource or is it just a "link" in the webservice?
+    def node_loaded?
+      #self.document.innerText.present? 
+      !self.document.empty?
+    end
+    
+    # Get all children with name
+    def nodes_with_name(name)      
+      self.document.children_of_type(name)
+    end
+    
+    # Get all attributes
+    def get_attributes
+      self.document.attributes
+    end
+    
+    # Get one specific attribute
+    def get_attribute(attribute)
+      self.document.get_attribute(attribute)
+    end
+    
+    # Get the value of the tag
+    def get_value
+      self.document.innerHTML
+    end
+     
+    # Get the name of the document   
+    def name
+      self.document.name
+    end
+    
+  end
+end

data/lib/tagcrumbs/proxy.rb

@@ -0,0 +1,32 @@
+module Tagcrumbs
+  # The Proxy class is used in resource associations to delay loading of a resource for as long as possible.
+  # Some method calls are directly forwarded to the resource, for others the resource is loaded first from the webservice
+  # and afterwards the call is made.
+  # The Proxy tries to be as transparent as possible so that you basically never know that you have a proxy object instead of a real resource.
+  class Proxy
+    UNPROXIED_METHODS = [:reload, :resource_url, :properties, :loaded?, :class] # TODO: figure out what other methods might be needed?
+
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ } # http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+
+    def initialize(object)
+      @object = object
+    end
+    
+    
+    # Forward all method calls to the proxied object, reload if necessary
+    def method_missing(method_name, *args, &block)
+      #puts "** Proxying #{method_name}. Loaded: #{@object.loaded?}"
+      
+      if @object.loaded? || UNPROXIED_METHODS.include?(method_name) #|| !@object.respond_to?(method_name) # having this doesn't allow first etc on arrays
+        @object.send(method_name, *args, &block)
+      else 
+        #puts "** Reloading"
+        @object.reload if @object.resource_url.present?
+        @object.send(method_name, *args, &block)
+      end
+      
+      
+    end
+  end
+  
+end