lexile 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a9d8c608432170762a600d4381ab5bc7eec7017
-  data.tar.gz: 55283e4b04b6abd7d4623cf091b870cbaff7b2b4
+  metadata.gz: 6fb1bf0a8ef1cde0481ba7c7f71b612705ee2ba1
+  data.tar.gz: 14b12295e34c5dbfc326e98fb403c3bdce1e979e
 SHA512:
-  metadata.gz: 8680d0ef2d8c642a47a559aecd47b82a72dc246de2fbdb14a62ffe3b65664e419a3766585244b9b478c80ccf1fc04264194459ce1db645014a63f96c7dee4df5
-  data.tar.gz: b61f7210672836096a621cfbd1c395f0b397719fa2f4b5ade0c8590557b196b9be8e839ce2344434aa288f86c75daf36fea8593b3fdcaa052cc0b6627bc16ebf
+  metadata.gz: 14f9461ddfb86c80d6568ed4e044d5315772b7bb58e79782b6617fe4739db8846dec8aadbb886c8890698a78b96959bba6a54eac82ac6a05e0759948766c6d36
+  data.tar.gz: 0718ec372bf2e13c02c2e74f624ec258b9bea2de351d4d154a500bf52144cee10fb256bb97b8707e50e68f08b177c988b9882300b610eb5814b07f2ba50609f2

data/Gemfile

@@ -3,15 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in lexile.gemspec
 gemspec
 
-gem 'httparty',   '~> 0.10'
-gem 'hashie'    
-
-group :development, :test do
-  gem 'rspec', '~> 2'
-  gem 'webmock'
-  gem 'vcr',   '~> 2.8'
-  gem 'jeweler'
-  gem 'factory_girl'
-end
-
 gem "codeclimate-test-reporter", group: :test, require: nil

data/README.md

@@ -8,15 +8,18 @@
 This gem wraps a portion of the Lexile database API. You need to obtain an
 authorized username and password from Lexile to use the API. This gem is not
 meant to be a comprenhensive implementation of the API just a bare bones
-"Find the Lexile for a Specific Book" solution.
+"Find the Lexile for a Specific Book or Update your Lexile DB" solution.
 
-The gem only covers the endpoints to the `book` resource, the `category` and
+The gem only covers the endpoint to the `book` resource, the `category` and
 `serial` resources are beyond the scope of this gem . If you need access
  to these resources feel free to submit a PR with code and specs.
 
-The gem does not support pagination for result-sets longer than 20 books, while
-the API contains all provisions for pagination, it is beyond the scope of the
-gem to expose those.
+The gem now supports pagination for long result-sets using the `next` and `previous` links
+of the `meta` element of the response. Pagination is implemented as an Enumerable and it is
+transparent when you traverse the enumerable with each, select, map, etc.... ( `count` will
+paginate the whole collection, a more efficient implementation using the `total_count` from 
+the `meta` is left as practice for the reader)
+
 
 ## Installation
 
@@ -39,7 +42,8 @@ Or install it yourself as:
     end
 
 ## Usage
-
+```
+    # FIND BY LEXILE ID
     >>  b = Lexile.books.show("315833")
     #<Lexile::Book id= "315833" ISBN="006201272X" ISBN13="9780062012722" ... >
 
@@ -47,24 +51,44 @@ Or install it yourself as:
     "It Happened to Nancy: By An Anonymous Teenager: A True Story from Her Diary"
 
 
-
-    >> b = Lexile.books.find_by_isbn13("9780062012722")
+    # FIND BY ISBN13
+    >> b = Lexile.books.find_by_isbn13("9780062012722").first
     [#<Lexile::Book ISBN="006201272X" ISBN13="9780062012722" ... >]
 
     >>  b[0].title
     "It Happened to Nancy: By An Anonymous Teenager: A True Story from Her Diary"
 
 
-
-    >>  b = Lexile.books.find_by_title("to Nancy")
-    [#<Lexile::Book ISBN="0380773155" ISBN13="9780380773152" ... >, #<Lexile::Book ISBN="006201272X" ISBN13="9780062012722" ... >]
-
-    >> b.length
-    2
-
-    >>  b[0].title
+    # FIND BY TITLE
+    >>  books = Lexile.books.find_by_title("to Nancy")
+    books.count
+    >> 2
+    
+    books.each do |b|
+        puts b.ISBN13
+    end
+    >>  9780380773152
+    >>  9780062012722
+  
+    >>  books.first.title
     "It Happened to Nancy: By An Anonymous Teenager: A True Story from Her Diary"
 
+    # GET LATEST UPDATES TO DB ( supports paging )
+    books = Lexile.books.find( timestamp__gte: '2015-08-04', limit:100 )
+    # will load pages of 100 elements at a time until there are no further pages
+    books.each do |b|
+            ....
+    end
+    
+    books.first
+    >>[#<Lexile::Book ISBN="006201272X" ISBN13="9780062012722" ... >]
+    
+    books.fist(20).last
+    >>[#<Lexile::Book ISBN="00620XXX" ISBN13="9780063013733" ... >]
+    
+    books.count
+    >>107  #will paginate through the whole collection
+```        
 
 ## Contributing
 
@@ -78,7 +102,7 @@ Or install it yourself as:
 
 The MIT License (MIT)
 
-Copyright (c) 2014 Curriculet Inc
+Copyright (c) 2015 Curriculet Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lexile"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+Lexile.configure do |config|
+     config.username     = ENV['LEXILE_USERNAME']
+     config.password     = ENV['LEXILE_PASSWORD']
+end
+
+
+require "irb"
+IRB.start

data/lexile.gemspec

@@ -22,4 +22,12 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "httparty", "~> 0.10"
   spec.add_runtime_dependency "hashie"
+
+  spec.add_development_dependency "bundler", ">= 1.3.0","< 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 2"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr", "~> 2.8"
+  spec.add_development_dependency "jeweler"
+
 end

data/lib/lexile.rb

@@ -15,6 +15,9 @@ require 'lexile/book'
 require 'lexile/api/resource'
 require 'lexile/api/books'
 require 'lexile/api/endpoints'
+require 'lexile/api/page'
+require 'lexile/api/page_list'
+require 'lexile/api/result_list'
 
 module Lexile
   extend Configuration

data/lib/lexile/api/books.rb

@@ -4,13 +4,14 @@ module Lexile
       api_model Lexile::Book
 
       def show id
-        response = @client.get( "#{ api_model.api_path }/#{id}" )
-        api_model.parse(response.body)
+        response_json = @client.get( "#{Lexile.api_version}/#{ api_model.api_path }/#{id}" )
+        api_model.parse( response_json )
       end
 
       def find( query_params )
-        response = @client.get( "#{ api_model.api_path }", query_params )
-        api_model.parse(response.body)
+        Lexile::Api::PageList.new( @client, api_model,  query_params ).to_results_list
+        #response_json = @client.get( "#{ api_model.api_path }", query_params )
+        #api_model.parse( response_json )
       end
 
       def find_by_isbn13 isbn13

data/lib/lexile/api/client.rb

@@ -52,12 +52,13 @@ module Lexile
         
         yield get_args if block_given? 
                 
-        #puts "CALLING API: #{Lexile.api_url}#{path} ===#{get_options}"
+        puts "CALLING API: #{Lexile.api_url}#{path} ===#{get_args}"
         response = self.class.get( path, get_args)
 
         case response.code
         when 200..201
           response
+          JSON.parse( response.body )
         when 400
           raise Lexile::BadRequest.new(response, params)
         when 401
@@ -84,12 +85,12 @@ module Lexile
       # @return [Hash] The properly formated get_options.
       def build_get_args( params={}, user_headers={})
         get_args = {}
-        query ={ format: 'json'} #all requests get this query params
+        query ={} #all requests get these query params
 
         query.merge!(params)
 
-        # pass any headers
-        headers ={}
+
+        headers ={ 'Accept' => 'application/json'} #all requests get these headers
         headers.merge!( user_headers )
 
         get_args[:query]      = query

data/lib/lexile/api/page.rb

@@ -0,0 +1,74 @@
+module Lexile
+  module Api
+    # Represents a page of data
+    class Page
+      include Enumerable
+
+      # Request a page of data and store the results in this instance
+      # @api private
+      # @return [Lexile::Api::Page]
+      # @example
+      #   page = Page.new '/v2.1/book'
+      def initialize(client, api_model, uri, query_params = {})
+        @client          = client
+        @api_model       = api_model
+        @uri             = uri
+        @query_params    = query_params
+
+        response_json = @client.get( uri, @query_params )
+        @all = api_model.parse(response_json)
+
+        raise Lexile::CannotProcessResponse.new('[:meta] is not present in response') unless response_json.has_key?('meta')
+
+        @limit        = response_json['meta']['limit']
+        @next         = response_json['meta']['next']
+        #puts "NEXT URI IS ==>#{@next}<=="
+        @offset       = response_json['meta']['offset']
+        @previous     = response_json['meta']['previous']
+        @total_count  = response_json['meta']['total_count']
+      end
+
+      # Gets next page if one is present, nil otherwise
+      # @api private
+      # @return [Lexile::Api::Page, nil] Next page, or nil if last
+      # @example
+      #   next_page = page.next
+      #   unless next_page.nil?
+      #     next_page.each do |elem| puts elem; end
+      def next
+        return nil if @next.nil?
+        Page.new( @client, @api_model, @next, {}  )
+      end
+
+      # Iterate over all elements in the page
+      # @api private
+      # @return [Array] List of all elements
+      # @example
+      #   page.each { |elem| puts elem }
+      def each(&blk)
+        @all.each(&blk)
+      end
+
+      # Get all elements in page
+      # @api private
+      # @return [Array] List of all elements
+      # @example
+      #   all_elems = page.all
+      attr_reader :all
+
+      # Retrieve the last element or n elements in the resource
+      # @api public
+      # @param num [nil, Integer] If nil, last elem; else, num elems to fetch
+      # @return [Lexile::Model, Lexile::Api::Page] elem, or
+      #   elems found. If list, sorted in ascending order of ids.
+      # @example
+      #   books = Lexile.books.first(20)
+      #   last_elem = books.last
+      #   last_elems = books.last 5
+      def last(num = nil)
+        return @all.last num if num
+        @all.last
+      end
+    end
+  end
+end

data/lib/lexile/api/page_list.rb

@@ -0,0 +1,44 @@
+module Lexile
+  module Api
+    # Handles paginated requests.
+    class PageList
+      include Enumerable
+
+      # Create a new PageList, without making any requests immediately
+      # @api private
+      # @return [PageList]
+      def initialize(client, api_model, query_params = {})
+        @client       = client
+        @api_model    = api_model
+        @uri          = "#{Lexile.api_version}/#{api_model.api_path}"
+        @query_params = query_params
+      end
+
+      # Iterate through each page, making requests as you iterate
+      # @api private
+      # @return [nil]
+      # @example
+      #   pagelist.each do |page|
+      #     page.each do |elem|
+      #       puts elem
+      #     end
+      #   end
+      def each
+        page = Page.new( @client, @api_model, @uri, @query_params )
+        until page.nil?
+          yield page
+          page = page.next
+        end
+      end
+
+      # Convert PageList into a ResultsList for easier iteration
+      # @api private
+      # @return [Lexile::Api::ResultsList]
+      # @example
+      #   pagelist.to_results_list.each { |elem| puts elem }
+      def to_results_list
+        Lexile::Api::ResultsList.new( self )
+      end
+    end
+  end
+end

data/lib/lexile/api/result_list.rb

@@ -0,0 +1,31 @@
+module Lexile
+  module Api
+    # Represents a list of results for a paged request.
+    class ResultsList
+      include Enumerable
+
+      # Create a results list from a PageList
+      # @api private
+      # @return [ResultsList]
+      def initialize( page_list )
+        @pages = page_list
+      end
+
+      # Iterate over results list
+      # @api public
+      # @return [nil]
+      # @example
+      #   results = Lexile::Book.find # returns a ResultsList
+      #   results.each do |book|
+      #     puts district.title
+      #   end
+      def each
+        @pages.each do |page|
+          page.each do |elem|
+            yield elem
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lexile/book.rb

@@ -2,7 +2,7 @@ module Lexile
   class Book < Hashie::Mash
     include Lexile::Model
 
-    api_path '/book'
+    api_path 'book'
 
     # Book Resource
     #

data/lib/lexile/configuration.rb

@@ -6,8 +6,8 @@ module Lexile
     #@!visibility private
     VALID_CONFIG_KEYS     = VALID_CONNECTION_KEYS + VALID_OPTIONS_KEYS
 
-    DEFAULT_ENDPOINT      = 'https://fabapi.lexile.com/api/fab'
-    DEFAULT_API_VERSION   = 'v2'
+    DEFAULT_ENDPOINT      = 'https://fabapi.lexile.com'
+    DEFAULT_API_VERSION   = '/api/fab/v2.1'
     DEFAULT_USER_AGENT    = 'Lexile API Ruby Gem by Curriculet'.freeze
     DEFAULT_TIMEOUT       = nil
     DEFAULT_TESTING       = false
@@ -45,15 +45,19 @@ module Lexile
     # Interpolate the base url for all calls
     # return [String] the base url for all api calls
     def api_url( path = nil)
-      [endpoint,api_version,path].compact.join('/')
+      [endpoint,path].compact.join('/')
+    end
+
+    def config
+      self
     end
 
     # Yields itself for use in the configuration block
     # @example
     #  Lexile.configure do |c|
     #    c.api_key    = <MY-API-KEY>
-    #    c.api_verion = 'v2'
-    #    c.endpoint   = 'https://fabapi.lexile.com/api/fab/'
+    #    c.api_verion = '/api/fab/v2'
+    #    c.endpoint   = 'https://fabapi.lexile.com'
     #    c.timeout    = '10' #seconds
     #    c.testing    = true
     #  end

data/lib/lexile/model.rb

@@ -84,8 +84,7 @@ module Lexile
 
       # Parses a request.body response into a Lexile::Model objects
       #
-      def parse( raw_json )
-        parsed_json = String === raw_json ? JSON.parse(raw_json) : json
+      def parse( parsed_json )
         if parsed_json.has_key?('objects')
           #this is a multi record and data should contain an array
           unless parsed_json['objects'].is_a? Array

data/lib/lexile/version.rb

@@ -1,3 +1,3 @@
 module Lexile
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/lexile/api/books_spec.rb

@@ -40,12 +40,12 @@ describe Lexile::Api::Books,  :vcr => { :cassette_name => "books" } do
       expect(books).to_not be_nil
     end
 
-    it 'should be array' do
-      expect(books).to be_an_instance_of( Array )
+    it 'first(10) should be array' do
+      expect(books.first(10)).to be_an_instance_of( Array )
     end
 
-    it 'length should be > 0' do
-      expect(books.length).to_not be_zero
+    it 'count should be > 0' do
+      expect(books.count).to_not be_zero
     end
 
     it 'should be array of Lexile::Book' do
@@ -55,19 +55,19 @@ describe Lexile::Api::Books,  :vcr => { :cassette_name => "books" } do
     end
 
     it 'should have id key' do
-      expect(books[0]).to respond_to(:id)
+      expect(books.first).to respond_to(:id)
     end
 
     it 'should have lexile key' do
-      expect(books[0]).to respond_to(:lexile)
+      expect(books.first).to respond_to(:lexile)
     end
 
     it 'should have lexile_display key' do
-      expect(books[0]).to respond_to(:lexile_display)
+      expect(books.first(5)[0]).to respond_to(:lexile_display)
     end
 
     it 'should have pages key' do
-      expect(books[0]).to respond_to(:pages)
+      expect(books.first).to respond_to(:pages)
     end
   end
 
@@ -78,12 +78,12 @@ describe Lexile::Api::Books,  :vcr => { :cassette_name => "books" } do
        expect(books).to_not be_nil
      end
 
-     it 'should be array' do
-       expect(books).to be_an_instance_of( Array )
+     it 'first(10) should return array' do
+       expect(books.first(10) ).to be_an_instance_of( Array )
      end
 
-     it 'length should be > 0' do
-       expect(books.length).to_not be_zero
+     it 'count should be > 0' do
+       expect(books.count).to_not be_zero
      end
 
      it 'should be array of Lexile::Book' do
@@ -93,19 +93,19 @@ describe Lexile::Api::Books,  :vcr => { :cassette_name => "books" } do
      end
 
      it 'should have id key' do
-       expect(books[0]).to respond_to(:id)
+       expect(books.first).to respond_to(:id)
      end
 
      it 'should have lexile key' do
-       expect(books[0]).to respond_to(:lexile)
+       expect(books.first).to respond_to(:lexile)
      end
 
      it 'should have lexile_display key' do
-       expect(books[0]).to respond_to(:lexile_display)
+       expect(books.first).to respond_to(:lexile_display)
      end
 
      it 'should have pages key' do
-       expect(books[0]).to respond_to(:pages)
+       expect(books.first).to respond_to(:pages)
      end
    end