pillboxr 0.0.3 → 0.6.0

data/lib/pillboxr/attributes.rb

@@ -0,0 +1,267 @@
+# -*- encoding: utf-8 -*-
+require_relative 'constants'
+require 'erb'
+
+module Pillboxr
+  module Attributes
+    def attributes
+      { :color                => :splcolor,
+        :shape                => :splshape,
+        :product_code         => :product_code,
+        :schedule             => :dea_schedule_code,
+        :ingredients          => :ingredients,
+        :imprint              => :splimprint,
+        :id                   => :spl_id,
+        :ndc9                 => :ndc9,
+        :size                 => :splsize,
+        :score                => :splscore,
+        :rxcui                => :rxcui,
+        :rxtty                => :rxtty,
+        :rxstring             => :rxstring,
+        :image                => :has_image,
+        :image_id             => :image_id,
+        :setid                => :setid,
+        :author               => :author,
+        :inactive_ingredients => :spl_inactive_ing,
+        :lower_limit          => :lower_limit }
+    end
+
+    def api_attributes
+      attributes.invert
+    end
+
+    # Creates a series of class methods on Pillboxr::Attributes module
+    # that allow easy access to all the possible colors, shapes, dea codes, etc..
+    # Example:
+    #
+    # Pillboxr::Attributes.colors
+    # => [:bullet,:capsule,:clover,:diamond,:double_circle,:freeform,:gear,:heptagon,
+    #     :hexagon,:octagon,:oval,:pentagon,:rectangle,:round,:semi_circle,:square,
+    #     :tear,:trapezoid,:triangle]
+    #
+    # Available methods are colors, color_codes, shapes, shape_codes, dea_codes,
+    # and schedule_codes.
+    self.constants.each do |const|
+      self.module_eval("def self.#{const.downcase}; #{const}.keys; end")
+    end
+
+    class Color
+      attr_accessor :color
+
+      def initialize(color_arg)
+        # puts "argument to method = #{color_arg}"
+        @color = case color_arg
+        when NilClass;  raise ColorError
+        when Array;     color_arg.size > 1 ? Pill::Attributes::Colors.new(color_arg) : COLORS[color_arg[0]]
+        when Symbol;    COLORS.fetch(color_arg, color_arg)
+        when String;    COLORS.fetch(color_arg.to_sym, color_arg.to_sym)
+        else raise "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&color=" + String(@color)
+      end
+    end
+
+    class Shape
+      attr_accessor :shape
+
+      def initialize(shape_arg)
+        # puts "argument to method = #{shape_arg}"
+        @shape = case shape_arg
+        when NilClass;              raise ShapeError
+        when Array;                 shape_arg.size > 1 ? Pill::Attributes::Shapes.new(color_arg) : SHAPES[shape_arg[0]]
+        when /^([Cc]{1}\d{5})+/;    shape_arg # valid hex
+        when Symbol;                SHAPES.fetch(shape_arg, shape_arg)
+        when String;                SHAPES.fetch(shape_arg.to_sym, shape_arg.to_sym)
+        else raise "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&shape=" + String(@shape)
+      end
+    end
+
+    class Productcode
+      attr_accessor :product_code
+
+      def initialize(product_code_arg)
+        # puts "argument to method = #{product_code_arg}"
+        @code = case product_code_arg
+        when NilClass;   raise ProductcodeError
+        when Array;      raise "product_code must be unique."
+        when /^\d+-\d+/; product_code_arg # valid hex
+        when Symbol;     raise "product_code cannot be a symbol."
+        else raise "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&prodcode=" + String(@code)
+      end
+    end
+
+    class Schedule
+      attr_accessor :schedule
+
+      def initialize(schedule_code)
+        # puts "argument to method = #{schedule_code}"
+        @schedule = case schedule_code
+        when NilClass;                  raise ScheduleError
+        when Array;                     schedule_code.size > 1 ? Pill::Attributes::Schedules.new(color_arg) : DEA_CODES.fetch(schedule_code[0])
+        when /^([Cc]{1}\d{5})+/;        schedule_code # valid hex
+        when /\AI{1,3}\z|\AIV\z|\AV\z/; DEA_CODES.fetch(schedule_code, schedule_code)
+        else raise "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&dea=" + String(@schedule)
+      end
+    end
+
+    class Ingredients
+      attr_accessor :ingredients
+
+      def initialize(ingredient_arg)
+        # puts "argument to method = #{ingredient_arg}"
+        @ingredients = case ingredient_arg
+        when NilClass; raise IngredientError
+        when Array;    raise ArgumentError, "can only search for one active ingredient at this time."
+        when String;   ingredient_arg
+        when Symbol;   String(ingredient_arg)
+        else raise ArgumentError, "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&ingredient=" + String(@ingredients)
+      end
+    end
+
+    # class Imprint # Broken currently
+    #   attr_accessor :imprint
+
+    #   def initialize(imprint_arg)
+    #     # puts "argument to method = #{ingredient_arg}"
+    #     @imprint = case imprint_arg
+    #     when NilClass; raise ImprintError
+    #     when Array;    raise ArgumentError, "can only search for one imprint string at this time."
+    #     when String;   imprint_arg
+    #     when Symbol;   imprint_arg
+    #     when Integer;  imprint_arg
+    #     else raise ArgumentError, "invalid arguments."
+    #     end
+    #     return self
+    #   end
+
+    #   def to_param
+    #     "&imprint=" + String(@imprint)
+    #   end
+    # end
+
+    class Size
+      attr_accessor :size
+
+      def initialize(size_arg)
+        @size = case size_arg
+        when NilClass; raise SizeError
+        when Integer;  size_arg
+        when Float;    Integer(size_arg)
+        when String;   Integer(size_arg)
+        when Symbol;   Integer(size_arg)
+        else raise ArgumentError, "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&size=" + String(@size)
+      end
+
+    end
+
+
+    class Score
+      attr_accessor :score
+
+      def initialize(score_arg)
+        # puts "argument to method = #{score_arg}"
+        @score = case score_arg
+        when NilClass;   raise ScoreError
+        when TrueClass;  2
+        when FalseClass; 1
+        when Integer;    score_arg
+        when Array;      raise ArgumentError, "Must be true or false."
+        else raise ArgumentError, "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&score=" + String(@score)
+      end
+    end
+
+    class Image
+      attr_accessor :image
+
+      def initialize(image_arg)
+        # puts "argument to method = #{image_arg}"
+        @image = case image_arg
+        when NilClass;   raise ImageError
+        when TrueClass;  1
+        when FalseClass; 0
+        when Array;      raise ArgumentError, "Must be true or false."
+        else raise ArgumentError, "Invalid argument. Must be true or false."
+        end
+        return self
+      end
+
+      def to_param
+        "&has_image=" + String(@image)
+      end
+    end
+
+    class Author
+      attr_accessor :author
+
+      def initialize(author_arg)
+        @author = case author_arg
+        when String; author_arg
+        when Array;  raise ArgumentError, "Author can only take a single string."
+        else raise ArgumentError, "invalid arguments."
+        end
+        return self
+      end
+
+      def to_param
+        "&author=" + ERB::Util.url_encode(@author)
+      end
+    end
+
+    class Lowerlimit
+      attr_accessor :lower_limit
+
+      def initialize(limit = DEFAULT_LOWER_LIMIT)
+        @lower_limit = case limit
+        when NilClass; raise LowerLimitError
+        when Integer;  limit
+        else raise ArgumentError, "Lower limit must be an integer."
+        end
+        return self
+      end
+
+      def to_param
+        "&lower_limit=" + String(@lower_limit)
+      end
+    end
+  end
+end

data/lib/pillboxr/constants.rb

@@ -0,0 +1,61 @@
+# -*- encoding: utf-8 -*-
+module Pillboxr
+    RECORDS_PER_PAGE    = 201
+    DEFAULT_LOWER_LIMIT = 1
+    BASE_URI = 'pillbox.nlm.nih.gov'
+    NO_RECORDS_ERROR_MESSAGE = "The document \"No records found\" does not have a valid root"
+    API_KEY_ERROR_MESSAGE = "The document \"Key does not match, you may not access this service\" does not have a valid root"
+
+  module Attributes
+    SHAPES = {
+        :bullet=> :C48335,
+        :capsule=> :C48336,
+        :clover=> :C48337,
+        :diamond=> :C48338,
+        :double_circle=> :C48339,
+        :freeform=> :C48340,
+        :gear=> :C48341,
+        :heptagon=> :C48342,
+        :hexagon=> :C48343,
+        :octagon=> :C48344,
+        :oval=> :C48345,
+        :pentagon=> :C48346,
+        :rectangle=> :C48347,
+        :round=> :C48348,
+        :semi_circle=> :C48349,
+        :square=> :C48350,
+        :tear=> :C48351,
+        :trapezoid=> :C48352,
+        :triangle=> :C48353
+    }
+
+    SHAPE_CODES = SHAPES.invert
+
+    COLORS = {
+        :black => :C48323,
+        :blue => :C48333,
+        :brown => :C48332,
+        :gray => :C48324,
+        :green => :C48329,
+        :orange => :C48331,
+        :pink => :C48328,
+        :purple => :C48327,
+        :red => :C48326,
+        :turquoise => :C48334,
+        :white => :C48325,
+        :yellow => :C48330
+    }
+
+    COLOR_CODES = COLORS.invert
+
+    DEA_CODES = {
+        :I   => :C48672,
+        :II  => :C48675,
+        :III => :C48676,
+        :IV  => :C48677,
+        :V   => :C48679
+    }
+
+    SCHEDULE_CODES = DEA_CODES.invert
+  end
+end

data/lib/pillboxr/extensions.rb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+require_relative 'attributes'
+
+module Pillboxr
+  module Extensions
+    def to_constant
+      raise TypeError unless self.kind_of?(String)
+      Array(self).inject(Pillboxr::Attributes) { |s,e| s.const_get(e.to_sym) }
+    end
+  end
+end

data/lib/pillboxr/pages.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+require 'forwardable'
+
+module Pillboxr
+  class Pages
+    extend Forwardable
+    def_delegators :@data, :<<, :size, :each, :include?, :empty?, :count,
+                   :join, :first, :last, :[], :[]=, :all?, :any?, :inject
+
+    def initialize(size = 0, obj = nil, &block)
+      @data = Array.new(size, &block)
+    end
+
+    def inspect
+      string = "#<Pillboxr::Result::Pages:#{object_id} ["
+      @data.each do |page|
+        string << String(page)
+        string << ", "
+      end
+      string << "], size = #{self.size}>"
+      return string
+    end
+
+    alias_method :to_s, :inspect
+
+    def start
+      self.current = @data[0]
+    end
+
+    def start?
+      self.current == @data[0]
+    end
+
+    def end
+      self.current = @data[-1]
+    end
+
+    def end?
+      self.current == @data[-1]
+    end
+
+    def advance(slots = 1)
+      slots.times { self.current = self.next }
+      return self.current
+    end
+
+    def retreat(slots = 1)
+      slots.times { self.current = self.previous }
+      return self.current
+    end
+
+    def next(slots = 1)
+      if slots == 1
+        self.end? ? @data[0] : @data[current_index + 1]
+      else
+        if slots <= (@data.size - (current_index + 1))
+          @data[(current_index + 1), slots]
+        else
+          temporary_array = @data[(current_index + 1)..-1].push(@data[0..(current_index - 1)]).flatten
+          return temporary_array[0..(slots - 1)]
+        end
+      end
+    end
+
+    def previous(slots = 1)
+      if slots == 1
+        self.start? ? @data[-1] : @data[current_index - 1]
+      else
+        if slots <= current_index
+          @data[(current_index - slots)..(current_index - 1)]
+        else
+          (@data[0..(current_index - 1)].reverse.push(@data[(current_index - slots)..-1].reverse)).flatten
+        end
+      end
+    end
+
+    def current
+      @data[current_index]
+    end
+
+    def current=(page)
+      unless page.current?
+        self.current.send(:current=, false)
+        page.send(:current=, true)
+      end
+      return page
+    end
+
+    def current_index
+      @data.index { |page| page.current }
+    end
+
+    private :current_index
+  end
+
+  Page = Struct.new(:current, :retrieved, :number, :pills, :params) do
+    def inspect
+      "<Page: current: #{current}, retrieved: #{retrieved}, number: #{number}, params: #{params}, #{pills.size} pills>"
+    end
+
+    def current?
+      self.current == true
+    end
+
+    def retrieved?
+      self.retrieved == true
+    end
+
+    def get
+      unless self.retrieved
+        self.pills = Result.subsequent(Request.new(self.params).perform)
+        puts "#{self.pills.size} records retrieved."
+        self.retrieved = true
+      end
+    end
+
+    alias_method :to_s, :inspect
+    private :current=, :retrieved=, :number=, :pills=, :params=
+  end
+end