lc-api 0.8.7 → 0.8.8

data/lib/lc-api/api.rb

@@ -11,17 +11,9 @@ module LcApi
       end
     end
     
-    class ResponseError < StandardError
-    end
-    
-    class NotFound < ResponseError
-    end
-    
-    class Forbidden < ResponseError
-    end
-    
-    class InternalServerError < ResponseError
-    end
-    
+    class ResponseError < StandardError; end
+    class NotFound < ResponseError; end
+    class Forbidden < ResponseError; end
+    class InternalServerError < ResponseError; end
   end
-end
+end

data/lib/lc-api/resource.rb

@@ -6,17 +6,30 @@ module LcApi
     class << self
       
       def find(id, options={})
-        uri = member_name
+        uri = member_name # ie 'message'
         uri += "/#{id}" if id
+        puts "uri is: #{uri}"
         parse_response(API.get(uri, options))
       end
       
       def all(options={})
-        uri = member_name
+        uri = member_name # get name of resource
         parse_response(API.get(uri, options), true)
       end
       
       def parse_response(response, multiple=false)
+        error_code_check(response)
+        
+        # build a single record and return if there is only one resource (via ".find" method)
+        return build_record(response.parsed_response) unless multiple
+        
+        # otherwise, build multiple records for multiple resources (via ".all" method)
+        resources = []
+        response.parsed_response.each { |rec| resources.push build_record(rec) }
+        return resources
+      end
+      
+      def error_code_check(response)
         case response.code.to_i
         when 404
           raise LcApi::API::NotFound.new(response), "Resource was not found"
@@ -25,57 +38,43 @@ module LcApi
         when 500
           raise LcApi::API::InternalServerError.new(response), "500 Internal Server error"
         end
-        
-        return build_record(response.parsed_response) unless multiple
-        
-        resources = []
-        response.parsed_response.each do |rec|
-          resources.push build_record(rec)
-        end
-        return resources
       end
       
       def build_record(response)
         attributes = {}
-        response.each_pair do |key, val|
-          attributes[key] = val if @attributes.include? key
-        end
+        response.each_pair { |k,v| attributes[k] = v if @attributes.include? k }
         new(attributes)
       end
       
       def member_name
-        name.split('::').last.downcase.pluralize
+        name.split('::').last.downcase.pluralize # pluralize from active_support/inflector
       end
       
       def define_attribute_methods(attributes)
         @attributes = attributes
-        
-        @attributes.each do |name|
-          define_method(name) { self[name] }
-        end
+        @attributes.each { |name| define_method(name) { self[name] }}
       end
     end
     
     attr_accessor :attributes
     
     def initialize attributes = {}
+      # raise error if user attempts to initialize a Resource by calling new
       raise Error, "#{self.class} is an abstract class and cannot be instantiated" if instance_of? Resource
       @attributes = {}
-      self.attributes = attributes
+      self.attributes = attributes # "attributes=" called
     end
     
-    def [](key)
-      @attributes[key]
+    def [](k) # "self[]" called externally, like so: "message.title" -- getter for keys and values (self[])
+      @attributes[k]
     end
     
-    def []=(key,value)
-      @attributes[key] = value if self.respond_to?(key)
+    def []=(k,v) # called internally -- setter for keys and values
+      @attributes[k] = v if self.respond_to?(k)
     end
     
     def attributes=(attributes = {})
-      attributes.each_pair do |key, val|
-        self[key] = val
-      end
+      attributes.each_pair { |k, v| self[k] = v } # []= method call
     end
     
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lc-api
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.8.8
   prerelease: 
 platform: ruby
 authors: