pillboxr 0.0.3 → 0.6.0

data/lib/pillboxr/params.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+module Pillboxr
+  class Params < Array
+
+    def initialize(size = 0, obj = nil, module_name, &block)
+      @module_name = module_name
+      super(size, obj, &block)
+    end
+
+    def concatenate
+      self.collect(&:to_param).join
+    end
+
+    def all(&block)
+      @module_name.send(:complete, &block)
+    end
+
+    def limit
+      if self.any? { |param| param.respond_to?(:lower_limit)}
+        limit = self.select { |param| param.respond_to?(:lower_limit) }.first.lower_limit
+        return limit
+      else
+        return DEFAULT_LOWER_LIMIT
+      end
+    end
+
+    def respond_to_missing(method_name, include_private = false) # :nodoc:
+      @module_name.send(:respond_to_missing, method_name, include_private)
+    end
+
+    def method_missing(method_name, *args)
+      puts "Params method missing called with #{method_name}."
+      @module_name.send(:method_missing, method_name, *args)
+    end
+  end
+end

data/lib/pillboxr/pill.rb

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+require_relative 'attributes'
+
+module Pillboxr
+  include Attributes
+  extend self
+  class Pill
+    Pillboxr.attributes.each do |k,v|
+      attr_accessor k.to_sym
+      alias_method v.to_sym, k.to_sym
+      alias_method (v.to_s + "=").to_sym, (k.to_s + "=").to_sym
+    end
+
+    def initialize(params_hash)
+      params_hash.each do |k,v|
+        self.send((k.downcase + "=").to_sym, v)
+      end
+    end
+
+    def color
+      Pillboxr::Attributes::COLOR_CODES[@color.to_sym]
+    end
+
+    def shape
+      Pillboxr::Attributes::SHAPE_CODES[@shape.to_sym]
+    end
+
+    def score
+      Integer(@score)
+    end
+
+    def score?
+      @score.to_i > 1 ? true : false
+    end
+
+    def image
+      @image.to_i == 1 ? true : false
+    end
+
+    def image?
+      @image.to_i == 1 ? true : false
+    end
+
+    def to_s
+      string = "#<Pillboxr::Pill:#{object_id} "
+      instance_variables.each do |ivar|
+        string << String(ivar)
+        string << " = "
+        string << (self.instance_variable_get(ivar) || "")
+        string << ", "
+      end unless instance_variables.empty?
+      string << ">"
+    end
+
+    def image_url(image_size = 'super_small')
+      unless image_id
+        return nil
+      end
+      case String(image_size)
+        when "super_small"; "http://pillbox.nlm.nih.gov/assets/super_small/#{image_id}ss.png"
+        when "small";       "http://pillbox.nlm.nih.gov/assets/small/#{image_id}sm.jpg"
+        when "medium";      "http://pillbox.nlm.nih.gov/assets/medium/#{image_id}md.jpg"
+        when "large";       "http://pillbox.nlm.nih.gov/assets/large/#{image_id}lg.jpg"
+        when "all"
+          ["http://pillbox.nlm.nih.gov/assets/super_small/#{image_id}ss.png",
+           "http://pillbox.nlm.nih.gov/assets/small/#{image_id}sm.jpg",
+           "http://pillbox.nlm.nih.gov/assets/medium/#{image_id}md.jpg",
+           "http://pillbox.nlm.nih.gov/assets/large/#{image_id}lg.jpg"]
+      end
+    end
+
+    alias_method :scored?, :score?
+  end
+end

data/lib/pillboxr/request.rb

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+require 'httparty'
+require_relative 'response'
+
+module Pillboxr
+  class Request
+    include HTTParty
+    format :xml
+    base_uri BASE_URI
+    parser(Class.new(HTTParty::Parser) do
+              def parse
+                begin
+                  body.gsub!(/^<disclaimer>.+<\/disclaimer>/, "")
+                  body.gsub!(/\s\&\s/, ' and ')
+                  super
+                rescue MultiXml::ParseError => e
+                  if e.message == NO_RECORDS_ERROR_MESSAGE
+                    result = {'Pills' => {'pill' => [], 'record_count' => 0 }}
+                    return result
+                  elsif e.message == API_KEY_ERROR_MESSAGE
+                    raise "Invalid api_key.yml. Check format and try again."
+                  else
+                    raise
+                  end
+                end
+              end
+            end)
+
+    attr_reader :full_path, :params, :api_response
+
+    def initialize(default_path = default_path, api_params)
+      @full_path = default_path + api_params.concatenate
+      @params = api_params
+      @api_response = Pillboxr::Response.new
+      @api_response.query = self
+    end
+
+    def perform
+      puts "path = #{default_path + params.concatenate}"
+      @api_response.body = self.class.get(full_path)
+      return self.api_response
+    end
+
+    private
+    def api_key
+      begin
+        @api_key ||= YAML.load_file(File.expand_path("api_key.yml"))
+      rescue Errno::ENOENT => e
+        raise e, "API key not found. You must create an api_key.yml file in the root directory of the project."
+      rescue TypeError => e
+        raise e, "api_key.yml does not contain an appropriate key."
+      end
+    end
+
+    def default_path
+      "/PHP/pillboxAPIService.php?key=#{api_key}"
+    end
+  end
+end

data/lib/pillboxr/response.rb

@@ -0,0 +1,8 @@
+# -*- encoding: utf-8 -*-
+module Pillboxr
+  Response = Struct.new(:body, :query) do
+
+
+  end
+
+end

data/lib/pillboxr/result.rb

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+require_relative 'pages'
+
+module Pillboxr
+  class Result
+
+    attr_accessor :record_count, :pages
+
+    def initialize(api_response, &block)
+      initial_page_number = Integer(api_response.query.params.limit / RECORDS_PER_PAGE )
+      @record_count = Integer(api_response.body['Pills']['record_count'])
+
+      puts "#{@record_count} records available. #{api_response.body['Pills']['pill'].size} records retrieved."
+
+      @pages = initialize_pages_array(api_response, initial_page_number)
+      @pages[initial_page_number].send(:pills=, self.class.parse_pills(api_response, @record_count))
+      api_response.query.params.clear
+      if block_given?
+        yield self
+      else
+        return self
+      end
+    end
+
+    def self.subsequent(api_response)
+      return parse_pills(api_response, RECORDS_PER_PAGE)
+    end
+
+    def self.parse_pills(api_response, record_count)
+      pills = []
+      if record_count == 1
+        pills << Pill.new(api_response.body['Pills']['pill'])
+      else
+        api_response.body['Pills']['pill'].each do |pill|
+          pills << Pill.new(pill)
+        end
+      end unless record_count == 0
+      return pills
+    end
+
+    def initialize_pages_array(api_response, initial_page_number)
+      unless record_count == 0
+        record_count.divmod(RECORDS_PER_PAGE).tap do |ary|
+          if ary[1] == 0
+            return Pages.new(ary[0]) do |i|
+              page_params = api_response.query.params.dup
+              page_params.delete_if { |param| param.respond_to?(:lower_limit)}
+              page_params << Attributes::Lowerlimit.new(i * RECORDS_PER_PAGE)
+              Page.new(i == initial_page_number, i == initial_page_number, i, [], page_params)
+            end
+          else
+            return Pages.new(ary[0] + 1) do |i|
+              page_params = api_response.query.params.dup
+              page_params.delete_if { |param| param.respond_to?(:lower_limit)}
+              page_params << Attributes::Lowerlimit.new(i * RECORDS_PER_PAGE)
+              Page.new(i == initial_page_number, i == initial_page_number, i, [], page_params)
+            end
+          end
+        end
+      end
+      return Pages.new(1) { |i| Page.new(true, true, i, [], api_response.query.params.dup)}
+    end
+
+    def inspect
+      string = "#<Pillboxr::Result:#{object_id} "
+      instance_variables.each do |ivar|
+        string << String(ivar)
+        string << " = "
+        string << (String(self.instance_variable_get(ivar)) || "")
+        string << ", " unless ivar == instance_variables.last
+      end unless instance_variables.empty?
+      string << ">"
+      return string
+    end
+
+    alias_method :to_s, :inspect
+    private :initialize_pages_array
+  end
+end

data/lib/pillboxr/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+module Pillboxr
+ VERSION = "0.6.0"
+end

data/pillboxr.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 require File.expand_path('../lib/pillboxr', __FILE__)
-require File.expand_path("../lib/version", __FILE__)
+require File.expand_path('../lib/pillboxr/version', __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "pillboxr"
@@ -11,18 +11,29 @@ Gem::Specification.new do |s|
   s.homepage    = "http://rubygems.org/gems/pillboxr"
   s.summary     = "Access the NLM Pillbox API using ActiveResource."
   s.description = <<-END
-Pillboxr is a subclass of ActiveResource::Base that provides additional convenience methods and some parameter wrapping for querying the Pillbox API Service located at http://pillbox.nlm.nih.gov/PHP/pillboxAPIService.php
+Pillboxr is a Ruby wrapper for the National Library of Medicine Pillbox API Service located at http://pillbox.nlm.nih.gov](http://pillbox.nlm.nih.gov).
+
+The pillbox API provides information from the FDA about various prescription medications.
+
+The current version of this library has two forms. The first (preferred) version does not depend on any gems except for `httparty`.
+The second version depends upon `active_resource`.
+This version of Pillboxr inherits from ActiveResource to perform its XML wrapping so ActiveResource 3.2.6 is a requirement for using the wrapper.
+
+This deprecated version is not included in the distributed gem but the library code can be found at [https://github.com/kgautreaux/pillboxr](https://github.com/kgautreaux/pillboxr).
+
+*Note:* This library is designed for use with Ruby 1.9.3 and above, and will not work with earlier versions of Ruby.
 END
 
-  s.required_rubygems_version = ">= 1.3.6"
+  s.required_rubygems_version = ">= 1.8.6"
   s.rubyforge_project         = "pillboxr"
-  
-  s.add_dependency 'activeresource', '> 2.3.5'
+
+  s.add_dependency 'httparty'
 
   s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "activeresource", "> 2.3.5"
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'vcr'
 
-  s.files        = `git ls-files`.split("\n")
+  s.files        = `git ls-files`.split("\n").delete_if { |fn| fn.match(/active(_|)resource/) }
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'
 end

data/test/pillboxr/attributes_test.rb

@@ -0,0 +1,15 @@
+require_relative 'test_helper'
+
+class TestAttributes < MiniTest::Unit::TestCase
+  def setup
+    extend Pillboxr::Attributes
+  end
+
+  def test_fetching_an_attribute
+    assert_equal(:splcolor, attributes.fetch(:color))
+  end
+
+  def test_fetching_an_api_attribute
+    assert_equal(:color, api_attributes.fetch(:splcolor))
+  end
+end

data/test/pillboxr/params_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+class TestParams < MiniTest::Unit::TestCase
+  def setup
+    @params = Pillboxr::Params.new(Pillboxr)
+  end
+
+  def test_creation_of_params
+    assert_equal([], @params)
+  end
+
+  def test_concatenate_method
+    5.times do
+      @params << Pillboxr::Attributes::Lowerlimit.new(0)
+    end
+    assert_equal("&lower_limit=0&lower_limit=0&lower_limit=0&lower_limit=0&lower_limit=0", @params.concatenate)
+  end
+
+  def test_limit_method
+    assert_equal(Pillboxr::DEFAULT_LOWER_LIMIT, @params.limit)
+    @params << Pillboxr::Attributes::Lowerlimit.new(300)
+    assert_equal(300, @params.limit)
+  end
+
+  def test_method_missing
+
+  end
+end

data/test/pillboxr/pill_test.rb

@@ -0,0 +1,20 @@
+require_relative 'test_helper'
+
+class TestPill < MiniTest::Unit::TestCase
+  def setup
+    @blue_pills = Pillboxr.color(:blue).image(true).all.pages.current.pills
+    @scored_pills = Pillboxr.score(3).all.pages.current.pills
+  end
+
+  def test_accessor_methods
+    @blue_pills.each do |pill|
+      assert_equal(:blue, pill.color)
+      assert_equal(true, pill.image?)
+    end
+
+    @scored_pills.each do |pill|
+      assert_equal(true, pill.scored?)
+      assert_equal(3, pill.score)
+    end
+  end
+end

data/test/pillboxr/pillboxr_test.rb

@@ -0,0 +1,167 @@
+require_relative 'test_helper'
+require 'vcr'
+
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'test/pillboxr/fixtures/vcr_cassettes'
+  c.hook_into :webmock
+  c.allow_http_connections_when_no_cassette = true
+end
+
+class TestPillboxr < MiniTest::Unit::TestCase
+  def setup
+    @num_round_shape_records = 11773
+    @num_blue_color_records = 2059
+    @num_image_records = 748
+    @num_blue_records_with_image = 69
+    @num_5_mm_records = 4724
+    @num_mylan_records = 753
+    @request_object = Pillboxr::Request.new(Pillboxr::Params.new([Pillboxr::Attributes::Shape.new(:round)]))
+  end
+
+  def test_api_key
+    assert_raises(NoMethodError) { Pillboxr::Request.api_key }
+    assert_raises(NoMethodError) do
+      @request_object.api_key
+    end
+  end
+
+  def test_returns_the_correct_default_path
+    assert_raises(NoMethodError) { @request_object.default_path }
+    assert_equal("/PHP/pillboxAPIService.php?key=#{@request_object.send(:api_key)}", @request_object.send(:default_path))
+  end
+
+  def test_returns_number_of_records
+    VCR.use_cassette(:round_shape) do
+      assert_equal(@num_round_shape_records, Pillboxr.with(:shape => :round).record_count)
+    end
+  end
+
+  def test_returns_no_records
+    VCR.use_cassette(:foo_shape) do
+      assert_equal(0, Pillboxr.with(:shape => :foo).record_count)
+    end
+  end
+
+  def test_all_valid_colors
+    VCR.use_cassette(:all_valid_colors) do
+      Pillboxr::Attributes::COLORS.keys.each do |color|
+        refute_equal([], Pillboxr.with(:color => color))
+      end
+    end
+  end
+
+  def test_all_valid_shapes
+    VCR.use_cassette(:all_valid_shapes) do
+      Pillboxr::Attributes::SHAPES.keys.each do |shape|
+        case shape
+        when :gear
+          assert_empty(Pillboxr.with(:shape => shape).pages.first.pills)
+        when :heptagon
+          assert_empty(Pillboxr.with(:shape => shape).pages.first.pills)
+        else
+          refute_empty(Pillboxr.with(:shape => shape).pages.first.pills, "shape is #{shape}")
+        end
+      end
+    end
+  end
+
+  def test_combination_hash
+    VCR.use_cassette(:combination_hash) do
+      assert_equal(@num_blue_records_with_image, Pillboxr.with({ :color => "blue", :image => true }).record_count)
+    end
+  end
+
+  def test_with_block_form
+    VCR.use_cassette(:with_block_form) do
+      @result = Pillboxr.with({:color => :blue}) do |r|
+        r.pages.each do |page|
+          page.get unless page.retrieved?
+        end
+      end
+    end
+    @result.pages.each { |page| assert page.retrieved? }
+    assert_equal(@num_blue_color_records, @result.pages.inject(0) { |sum, page| sum + page.pills.size })
+  end
+
+  def test_respond_to_missing
+    VCR.use_cassette(:respond_to_missing_shape) do
+      assert_equal(true, Pillboxr.respond_to?(:shape))
+    end
+  end
+
+  def test_method_missing_with_shape
+    VCR.use_cassette(:method_missing_shape) do
+      assert_equal(@num_round_shape_records, Pillboxr.shape(:round).all.record_count)
+    end
+  end
+
+  def test_method_missing_with_image
+    VCR.use_cassette(:method_missing_has_image) do
+      @result = Pillboxr.image(true).all
+    end
+
+    @result.pages.first.pills.each do |pill|
+      refute_nil(pill.image_url(:small))
+    end
+    assert_equal(@num_image_records, @result.record_count)
+  end
+
+  def test_method_missing_with_color
+    VCR.use_cassette(:method_missing_color) do
+      assert_equal(@num_blue_color_records, Pillboxr.color(:blue).all.record_count)
+    end
+  end
+
+  # def test_method_missing_with_imprint # Broken currently
+  #   VCR.use_cassette(:method_missing_imprint) do
+  #     assert_equal(@num_imprint_23_records, Pillboxr.imprint(23).all.record_count)
+  #   end
+  # end
+
+  def test_method_missing_with_size
+    VCR.use_cassette(:method_missing_size, :allow_playback_repeats => true) do
+      assert_equal(@num_5_mm_records, Pillboxr.size(5).all.record_count)
+      assert_equal(@num_5_mm_records, Pillboxr.size("5").all.record_count)
+    end
+  end
+
+  def test_method_missing_with_author
+    VCR.use_cassette(:method_missing_author) do
+      assert_equal(@num_mylan_records, Pillboxr.author("Mylan Pharmaceuticals Inc.").all.record_count)
+    end
+  end
+
+  def test_method_missing_with_lower_limit
+    VCR.use_cassette(:method_missing_with_lower_limit, :allow_playback_repeats => true) do
+      assert_equal(201, Pillboxr.shape(:round).lower_limit(202).all.pages.current.pills.size)
+    end
+  end
+
+  def test_with_lower_limit
+    VCR.use_cassette(:with_lower_limit, :allow_playback_repeats => true) do
+      assert_equal(201, Pillboxr.with({ :shape => :round, :lower_limit => 202 }).pages.current.pills.size)
+      first = Pillboxr.with({ :shape => :round }).pages.current.pills
+      second = Pillboxr.with({ :shape => :round, :lower_limit => 202 }).pages.current.pills
+      first.each { |p| refute_includes(second, p)}
+    end
+  end
+
+  def test_method_chaining
+    VCR.use_cassette(:method_chaining) do
+      assert_equal(@num_blue_records_with_image, Pillboxr.color(:blue).image(true).all.record_count)
+    end
+  end
+
+  def test_method_missing_with_a_block
+    VCR.use_cassette(:method_missing_with_a_block) do
+      @result = Pillboxr.image(true).all do |r|
+        r.pages.each do |page|
+          page.get unless page.retrieved?
+        end
+      end
+    end
+    @result.pages.each { |page| assert page.retrieved? }
+    assert_equal(@num_image_records, @result.pages.inject(0) { |sum, page| sum + page.pills.size })
+  end
+end