tagcrumbs-tagcrumbs 0.3.1

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