spigot 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43fb252116ef08da32e804dd2cd1a5bf1272f386
-  data.tar.gz: eb143439496123d5318df58b43bb353855ed9f32
+  metadata.gz: bbf49ff77ef26eb205af75ddcedcf4b7b980c213
+  data.tar.gz: 3dda020a7fa625e02bda396c46ac2575b1d3cdb5
 SHA512:
-  metadata.gz: 2b8c421ded53429d8569655cf014921af15656ba77479dd07e05bafde28df913022b5f591236552235980359598127b48ff234ebccc9d1ac7468c1164d8110b3
-  data.tar.gz: b08b8e03fb47aa5d5a474aca6eaa08d166fbba299e77afbd73af6e8430bbe1e9ce35c41278d18b6536f911804572acc74b9062f87ce992eae6cdfd0a253d154b
+  metadata.gz: 3caace51c1f63f2dd53d53d3a0a948513016f3b6735e186eea2089b6d005d4d49f40136360f82d393dcbba65c810af958551f5043922c7ebe2a53aadacf6a5c1
+  data.tar.gz: 3fd383bdd2948e1bb90e88c046b5a7a866027104c50b0f405333a679b3f13d3c1941977532971f9f4e7af9a03964ff8549c54a894978d239f47762808d0a8e40

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 .bundle
 .config
+.gitconfig
 .yardoc
 .rspec
 .DS_Store

data/README.md

@@ -1,7 +1,8 @@
 # Spigot
 
-[![Build Status](https://travis-ci.org/mwerner/spigot.png?branch=master)](https://travis-ci.org/mwerner/spigot)
-[![Code Climate](https://codeclimate.com/github/mwerner/spigot.png)](https://codeclimate.com/github/mwerner/spigot)
+[![Build Status](https://travis-ci.org/mwerner/spigot.png?branch=master)](https://travis-ci.org/mwerner/spigot, "Travis CI")
+[![Code Climate](https://codeclimate.com/github/mwerner/spigot.png)](https://codeclimate.com/github/mwerner/spigot, "Code Climate")
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/mwerner/spigot/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
 
 Spigot is an attempt to bring some sanity to consuming external API data. Without Spigot, you need
 to do this manual mapping at creation, such as:
@@ -28,10 +29,11 @@ to do this manual mapping at creation, such as:
     end
 
 This becomes particularly difficult as you start having multiple external sources for the same resource (ex: users from both twitter and facebook).
+
 Spigot uses a ruby api to map the data you receive to the columns of your database. As a result, you're
 able to convey a mapping of their structure into your attributes in a concise format. Afterwards, you can accomplish the above work in a simple statement:
 
-    User.find_or_create_by_api(:github, params[:data])
+    User.find_or_create_by_api(params[:data])
 
 Much better.
 

data/Rakefile

@@ -1,7 +1,3 @@
 require "bundler/gem_tasks"
-
-task :spec do
-  system("rspec spec/")
-end
-
+task(:spec){system("rspec spec/")}
 task :default => [:spec]

data/examples/active_record.rb

@@ -4,53 +4,43 @@ require 'net/http'
 require 'uri'
 
 ActiveRecord::Base.logger = Spigot.logger
-ActiveRecord::Base.establish_connection({
-  :adapter => "sqlite3",
-  :database => ':memory:'
-})
-
-ActiveRecord::Schema.define do
-  self.verbose = false
-  create_table :users, :force => true do |t|
-    t.integer :github_id
-    t.string  :username
-    t.string  :image_url
-    t.string  :profile_url
-  end
-end
+require_relative '../script/active_record'
 
-class User < ActiveRecord::Base
+class ActiveUser < ActiveRecord::Base
   include Spigot::Base
 end
 
-Spigot.resource :user do
+Spigot.resource :active_user do
   id :github_id
+  name :name
   login :username
-  avatar_url :image_url
-  url :profile_url
+  gravatar_id :token
   options do
     primary_key :username
   end
 end
 
-profile_url = "https://api.github.com/users/mwerner"
+profile_url = 'https://api.github.com/users/mwerner'
 puts "Making a request to an external API (Github): #{profile_url}"
 response = Net::HTTP.get_response URI.parse(profile_url)
 puts "Parse the response:\n `data = JSON.parse(response.body)`"
 data = JSON.parse(response.body)
 
-puts "\nIt Returned a whole bunch of data: "
-puts "#{data.inspect[0..100]}... etc, etc, etc (#{data.keys.length} more keys received)"
+puts "\nIt returns a whole bunch of data: "
+puts "#{data.inspect[0..100]} ... etc, etc, etc (#{data.keys.length} more keys received)"
 
-puts "\nWe don't want to use all of it. We can define a map on Spigot:"
-puts User.spigot.map.to_hash.inspect
-puts "Each key is an attribute received from the API, and the corresponding value is our column name."
+puts "\nWe don't want to use all of it. Let's define a map on Spigot:"
+puts ActiveUser.spigot.map.to_hash.inspect
+puts 'Each key is an attribute received from the API, the corresponding value is our column name.'
 
-puts "\nWe define our primary key in the spigot `User` options, so we know how to check if the record already exists:"
-puts User.spigot.options.inspect
+puts "\nWe define our primary key in the spigot `ActiveUser` options;"
+puts 'now we know how to check if the record already exists:'
+puts ActiveUser.spigot.options.inspect
 
+puts "\nWe can create a new user with one line: `ActiveUser.find_or_create_by_api(data)`"
+puts ActiveUser.find_or_create_by_api(data).inspect
 
-puts "\nWe can create a new user with one nice and easy line: `User.find_or_create_by_api(data)`"
-puts User.find_or_create_by_api(data).inspect
+puts "\nThen running it again, we'll see Spigot returns the existing record."
+puts ActiveUser.find_or_create_by_api(data).inspect
 
 puts "\nEnjoy!"

data/examples/model.rb

@@ -41,22 +41,22 @@ class User
 
   attr_reader :name, :username
 
-  def initialize(params={})
+  def initialize(params = {})
     params.each_pair do |k, v|
       instance_variable_set("@#{k}".to_sym, v)
     end
   end
 
   def self.api_data
-    { full_name: 'matthew', login: 'mwerner' }
+    { id: '9238475', full_name: 'matthew', login: 'mwerner' }
   end
 
   def self.build
-    new_by_api(:github, api_data)
+    new_by_api(github: api_data)
   end
 end
 
-puts "Map Built:"
+puts 'Map Built:'
 puts Spigot.config.map.to_hash
 
 user = User.build

data/examples/multi_resource.rb

@@ -0,0 +1,61 @@
+require 'active_record'
+require 'spigot'
+require 'net/http'
+require 'uri'
+
+ActiveRecord::Base.logger = Spigot.logger
+require_relative '../script/active_record'
+
+class Event < ActiveRecord::Base
+  include Spigot::Base
+end
+
+class ActiveUser < ActiveRecord::Base
+  include Spigot::Base
+end
+
+Spigot.define do
+  resource :active_user do
+    id :github_id
+    name :name
+    login :username
+    gravatar_id :token
+    options do
+      primary_key :username
+    end
+  end
+
+  resource :event do
+    id   :github_id
+    type :name
+    actor ActiveUser
+    options do
+      primary_key :id
+    end
+  end
+end
+
+events_url  = 'https://api.github.com/events'
+
+puts 'We can start off by making a request to get the latest github events'
+response = Net::HTTP.get_response URI.parse(events_url)
+puts "Parse the response:\n `data = JSON.parse(response.body)`"
+event_data = JSON.parse(response.body)
+
+puts "\nIt returns a whole bunch of data: "
+puts "#{event_data.inspect[0..100]} ... etc, etc, etc\n\n"
+
+puts 'Lets take the first three events and run them through spigot.'
+puts 'We only want a few attributes: id, type and the associated user.'
+puts Event.spigot.map.to_hash.inspect
+
+puts "We'll assign a primary key in our options to make sure we don't duplicate events"
+puts Event.spigot.options.inspect
+
+puts "\nWe can parse all the events with one nice and easy line: `Event.spigot.find_or_create(data)`"
+puts Event.spigot.find_or_create(event_data.first(3)).inspect
+
+puts "\nSpigot has used the ActiveUser spigot map to create users for each event"
+puts ActiveUser.all.map { |user| "#{user.id}: #{user.username}" }
+
+puts "\nEnjoy!"

data/lib/spigot.rb

@@ -1,7 +1,9 @@
-require "spigot/version"
-require "spigot/errors"
-require "spigot/patch"
+require 'spigot/version'
+require 'spigot/errors'
+require 'spigot/patch'
+require 'logger'
 
+# Parent module for Spigot
 module Spigot
   autoload :ActiveRecord,  'spigot/active_record'
   autoload :Base,          'spigot/base'
@@ -9,6 +11,7 @@ module Spigot
   autoload :Proxy,         'spigot/proxy'
   autoload :Record,        'spigot/record'
   autoload :Translator,    'spigot/translator'
+  # Spigot mapping and definition classes
   module Map
     autoload :Base,        'spigot/map/base'
     autoload :Definition,  'spigot/map/definition'
@@ -41,16 +44,17 @@ module Spigot
     Configuration.instance
   end
 
-  ##=> Support
+  # Support
   def self.root
     File.expand_path('../..', __FILE__)
   end
 
   def self.logger
     @log ||= Spigot.config.logger || begin
-      if buffer = Logger.new(STDOUT)
-        buffer.level = ($0 == 'irb' ? Logger::DEBUG : Logger::INFO)
-        buffer.formatter = proc{|severity, datetime, progname, msg| "#{msg}\n"}
+      buffer = Logger.new(STDOUT)
+      if buffer
+        buffer.level = ($PROGRAM_NAME == 'irb' ? Logger::DEBUG : Logger::INFO)
+        buffer.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
       end
       buffer
     end

data/lib/spigot/active_record.rb

@@ -1,58 +1,53 @@
 module Spigot
   module ActiveRecord
     module ClassMethods
-
       ## #find_by_api(params)
       # Build a query based on the defined map for this resource
       # to find a single matching record in the database
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def find_by_api(params={})
+      def find_by_api(params = {})
         find_all_by_api(params).first
       end
 
       ## #find_all_by_api(params)
       # Build a query based on the defined map for this resource
-      # to find all matching records in the database
+      # to find all matching records in the database.
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def find_all_by_api(params={})
-        service, data = Spigot::Map::Service.extract(params)
-        find_by_translator Translator.new(self, service, data)
+      def find_all_by_api(params = {})
+        find_by_translator params_to_translator(params)
       end
 
       ## #create_by_api(params)
       # Insert mapped data into the calling model's table. Does not
-      # do any checks on existing content already present in the database
+      # perform any checks on existing content already present in the database
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def create_by_api(params={})
-        service, data = Spigot::Map::Service.extract(params)
-        create_by_translator Translator.new(self, service, data)
+      def create_by_api(params = {})
+        create_by_translator params_to_translator(params)
       end
 
       ## #update_by_api(params)
-      # Queries the database to find an existing record, based on the options
-      # provided to spigot. If a record is found, it updates that record
-      # with any new data received by the API
+      # Queries the database to find an existing record.
+      # If a record is found, it updates that record
+      # with any new formatted data received by the API
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def update_by_api(params={})
-        service, data = Spigot::Map::Service.extract(params)
-        babel = Translator.new(self, service, data)
+      def update_by_api(params = {})
+        babel = params_to_translator(params)
         record = find_by_translator(babel).first
         update_by_translator(babel, record) if record.present?
       end
 
       ## #find_or_create_by_api(params)
       # Queries the database to find an existing record. If that record is found
-      # simply return it, otherwise create a new record and return it. This does
+      # simply return it, otherwise return a newly created record. This does
       # not update any existing record. If you want that, use `create_or_update_by_api`
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def find_or_create_by_api(params={})
-        service, data = Spigot::Map::Service.extract(params)
-        babel = Translator.new(self, service, data)
+      def find_or_create_by_api(params = {})
+        babel = params_to_translator(params)
         find_by_translator(babel).first || create_by_translator(babel)
       end
 
@@ -62,44 +57,44 @@ module Spigot
       # creates a new record and returns the newly created record.
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def create_or_update_by_api(params={})
-        service, data = Spigot::Map::Service.extract(params)
-        babel = Translator.new(self, service, data)
+      def create_or_update_by_api(params = {})
+        babel = params_to_translator(params)
         record = find_by_translator(babel).first
         record.present? ? update_by_translator(babel, record) : create_by_translator(babel)
       end
 
       private
 
+      def params_to_translator(params)
+        service, data = Spigot::Map::Service.extract(params)
+        Translator.new(self, service, data)
+      end
+
       def find_by_translator(translator)
         if invalid_primary_keys?(translator)
-          raise Spigot::InvalidSchemaError, "The #{translator.primary_key} column does not exist on #{self.to_s}"
-        end
-
-        if translator.id.blank?
-          Spigot.logger.warn "   <Spigot::Warning> No #{translator.service} API data found at :#{translator.foreign_key}"
+          message = "The #{translator.primary_key} column does not exist on #{to_s}"
+          raise Spigot::InvalidSchemaError, message
         end
 
         return [] if translator.conditions.blank?
-        self.where(translator.conditions)
+        where(translator.conditions)
       end
 
       def create_by_translator(translator)
-        Record.create(self, translator.format)
+        Record.create(translator.service, self, translator.format)
       end
 
       def update_by_translator(translator, record)
-        Record.update(self, record, translator.format)
+        Record.update(translator.service, self, record, translator.format)
         record
       end
 
       def invalid_primary_keys?(translator)
         [*translator.primary_key].each do |key|
-          return true unless self.column_names.include?(key.to_s)
+          return true unless column_names.include?(key.to_s)
         end
         false
       end
     end
-
   end
 end

data/lib/spigot/base.rb

@@ -11,24 +11,17 @@ module Spigot
       # Instantiate a new object mapping the api data to the calling object's attributes
       #
       # @param params [Hash] Data as received from the api with optional service key
-      def new_by_api(params)
-        Record.instantiate(self, formatted_api_data(params))
-      end
-
-      # #self.formatted_api_data(params)
-      # Create a Spigot::Translator for the given service and return the formatted data.
-      #
-      # @param params [Hash] Data as received from the api with optional service key
-      def formatted_api_data(params={})
+      def new_by_api(params = {})
         service, data = Spigot::Map::Service.extract(params)
-        Translator.new(self, service, data).format
+        translator = Translator.new(self, service, data)
+        Record.instantiate(service, self, translator.format)
       end
 
       # #self.spigot
       # Return a Spigot::Proxy that provides accessor methods to the spigot library
       #
-      # @param service [Symbol] Service which pertains to the data being processed on the implementation
-      def spigot(service=nil)
+      # @param service [Symbol] Data for service being processed on the implementation
+      def spigot(service = nil)
         Spigot::Proxy.new(self, service)
       end
     end

data/lib/spigot/configuration.rb

@@ -21,7 +21,7 @@ module Spigot
     end
 
     def reset
-      @@defaults.each_pair{|k,v| self.send("#{k}=",v)}
+      @@defaults.each_pair { |k, v| send("#{k}=", v) }
     end
   end
 end

data/lib/spigot/map/base.rb

@@ -1,7 +1,6 @@
 module Spigot
   module Map
     class Base
-
       attr_reader :services
 
       def initialize
@@ -14,7 +13,7 @@ module Spigot
       end
 
       def update(name, service)
-        @services.reject!{|s| s.name == name.to_s.underscore.to_sym}
+        @services.reject! { |s| s.name == name.to_s.underscore.to_sym }
         @services << service
       end
 
@@ -23,14 +22,14 @@ module Spigot
       end
 
       def service(name)
-        services.detect{|service| service.name == name.to_s.underscore.to_sym}
+        services.find { |service| service.name == name.to_s.underscore.to_sym }
       end
 
       def to_hash
-        hash = {};
+        hash = {}
         services.each do |service|
           service_map = {}
-          service.resources.each{|resource| service_map.merge!(resource.to_hash) }
+          service.resources.each { |resource| service_map.merge!(resource.to_hash) }
           hash.merge!(service.name.to_sym => service_map)
         end
         hash