verso 0.0.2 → 0.0.3

data/lib/verso/program_area.rb

@@ -1,39 +1,60 @@
 module Verso
-  class ProgramArea
-    include HTTPGet
-
-    def initialize(raw_category)
-      @raw_program_area = raw_category
-    end
-
-    def method_missing(mname)
-      if @raw_program_area[mname.to_s].nil?
-        @raw_program_area.merge!(
-          JSON.parse(http_get("/program_areas/"))["program_areas"].
-                       find { |c| c["title"] == @raw_program_area["title"] }
-          )
-      end
-      @raw_program_area[mname.to_s]
-    end
-
-    def description
-      ""
-    end
+  # Program Area
+  #
+  # Contained by {Verso::ProgramAreaList} resource
+  #
+  # @see http://api.cteresource.org/docs/program_areas
+  #
+  # @!attribute [r] deprecated
+  #   @return [Boolean] Is this Program Area deprecated?
+  # @!attribute [r] official
+  #   @return [Boolean] Is this an official VDOE Program Area?
+  # @!attribute [r] section_overview
+  #   @return [String] HTML-formatted text describing Program Area
+  # @!attribute [r] title
+  #   @return [String] Program Area title
+  # @!attribute [r] version_date
+  #   @return [String] Date of last update
+  #
+  # @overload initialize(attrs={})
+  #   @note Any attributes may be set upon instantiation, using Options Hash.
+  #     The following are required:
+  #   @option attrs [String] :title Program Area title *Required*
+  class ProgramArea < Verso::Base
+    include HTTPGettable
+    attr_reader :deprecated, :official, :section_overview, :title, :version_date
 
+    # @return [Array] Collection of related {Verso::Course} objects
     def courses
       @courses ||= CourseList.new(:program_area => slug.gsub('-', ' ')).
                      sort_by { |c| c.title + c.edition }.
                      uniq { |c| c.code + c.edition }
     end
 
+    # @return [String] Empty string to make consistent interface
+    def description
+      ""
+    end
+
+    # @return [String] Parameterized title
     def slug
       # swiped from ActiveSupport::Inflector
-      parameterized_string = @raw_program_area["title"].dup
+      parameterized_string = title.dup
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, '-')
       re_sep = Regexp.escape('-')
       parameterized_string.gsub!(/#{re_sep}{2,}/, '-')
       parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
       parameterized_string.downcase
     end
+
+  private
+
+    def path
+      "/program_areas/"
+    end
+
+    def fetch
+      super[:program_areas].find { |pa| pa[:title] == title }
+    end
   end
 end

data/lib/verso/program_area_list.rb

@@ -1,20 +1,24 @@
 module Verso
-  class ProgramAreaList
+  # Program Area List resource
+  #
+  # A collection of {Verso::ProgramArea} objects.
+  #
+  # @see http://api.cteresource.org/docs/program_areas
+  class ProgramAreaList < Verso::Base
     include Enumerable
-    include HTTPGet
+    include HTTPGettable
+    extend Forwardable
+    def_delegators :program_areas, :[], :each, :empty?, :last, :length
 
-    def program_areas
-      @program_areas ||= JSON.parse(
-        http_get('/program_areas/')
-      )["program_areas"].collect { |pa| ProgramArea.new(pa) }
-    end
+  private
 
-    def each &block
-      program_areas.each &block
+    def program_areas
+      @program_areas ||= get_attr(:program_areas).
+                           collect { |pa| ProgramArea.new(pa) }
     end
 
-    def last
-      program_areas[-1]
+    def path
+      "/program_areas/"
     end
   end
 end

data/lib/verso/standard.rb

@@ -1,37 +1,59 @@
 module Verso
-  class Standard
-    include HTTPGet
+  # Standard resource
+  #
+  # A standard that has been associated with a {Verso::Course}.
+  #
+  # @see http://api.cteresource.org/docs/courses/course/standards/standard
+  #
+  # @!attribute [r] code
+  #   @return [String] Course code
+  # @!attribute [r] edition
+  #   @return [String] Course edition year
+  # @!attribute [r] name
+  #   @return [String] Standard name used as an identifier
+  # @!attribute [r] title
+  #   @return [String] Standard title
+  #
+  # @overload initialize(attrs={})
+  #   @note Any attributes may be set upon instantiation, using Options Hash.
+  #     The following are required:
+  #   @option attrs [String] :code Course code *Required*
+  #   @option attrs [String] :edition Edition year *Required*
+  #   @option attrs [String] :name Standard name (identifier) *Required*
+  class Standard < Verso::Base
+   include HTTPGettable
+    attr_reader :code, :edition, :name, :title
 
-    def initialize(raw_standard, context=nil)
-      @raw_standard = raw_standard
-      @context = context
+    # @return [String] description
+    def description
+      get_attr(:description).to_s # sometimes nil
     end
 
-    def method_missing(mname)
-      if !@raw_standard.has_key?(mname.to_s)
-        @raw_standard.merge!(JSON.parse(
-          http_get("/courses/#{code},#{edition}/standards/#{name}")
-        )["standard"])
-      end
-      @raw_standard[mname.to_s]
+    # @return [Array] collection of goals with #title, #description strings
+    def goals
+      @goals ||= get_attr(:goals).
+        collect { |raw_standard| OpenStruct.new(raw_standard) }
     end
 
-    def code
-      @context && @context.code
-    end
 
-    def edition
-      @context && @context.edition
+    # @return [Array] collection of contained {Verso::Standard} objects
+    def sections
+      @sections ||= get_attr(:sections).
+        collect do |raw_section|
+          Standard.new(
+            raw_section.merge(:code => code, :edition => edition, :name => name)
+          )
+        end
     end
 
-    def sections
-      @sections ||= method_missing(:sections).
-        collect { |raw_section| Standard.new(raw_section, @context) }
+  private
+
+    def fetch
+      super[:standard]
     end
 
-    def goals
-      @goals ||= method_missing(:goals).
-        collect { |raw_standard| OpenStruct.new(raw_standard) }
+    def path
+      "/courses/#{code},#{edition}/standards/#{name}"
     end
   end
 end

data/lib/verso/standards_list.rb

@@ -1,49 +1,60 @@
 module Verso
-  class StandardsList
+  # Standards List resource
+  #
+  # A collection of {Verso::Standard} objects correlated to a {Verso::Course}.
+  #
+  # @see http://api.cteresource.org/docs/courses/course/standards
+  #
+  # @!attribute [r] code
+  #   @return [String] Course code
+  # @!attribute [r] edition
+  #   @return [String] Course edition year
+  #
+  # @overload initialize(attrs={})
+  #   @note Attributes required:
+  #   @option attrs [String] :code Course code *Required*
+  #   @option attrs [String] :edition Edition year *Required*
+class StandardsList < Verso::Base
     include Enumerable
+    include HTTPGettable
+    extend Forwardable
+    def_delegators :standards, :[], :each, :empty?, :last, :length
+    attr_reader :code, :edition
 
-    def initialize(raw, context=nil)
-      @raw_standards = raw.is_a?(Array) ? raw : raw.values
-      @context = context
-    end
-
-    def self.from_course(course)
-      raw_standards = JSON.parse(
-        Net::HTTP.get('api.cteresource.org',
-                      "/courses/#{course.code},#{course.edition}/standards/",
-                      80)
-      )["standards"]
-      StandardsList.new(raw_standards, course)
-    end
-
-    def standards
-      @standards ||= @raw_standards.
-        sort_by { |s| s["title"] }.
-        collect { |raw_standard| Standard.new(raw_standard, @context) }
+    # @return [Array] Non-SOL standards in this list
+    def non_sols
+      @non_sols ||= reject { |s| sol_titles.include?(s.title) }
     end
 
-    def each &block
-      standards.each &block
+    # @return [Array] SOL standards in this list
+    def sols
+      @sols ||= select { |s| sol_titles.include?(s.title) }
     end
 
-    def last
-      standards[-1]
+    # Find Standards by {Verso::Course}.
+    #
+    # @param course [Verso::Course] A {Verso::Course}
+    # @return [Verso::StandardsList] A {Verso::Course}'s standards
+    def self.from_course(course)
+      StandardsList.new(:code => course.code, :edition => course.edition)
     end
 
-    def empty?
-      standards.empty?
-    end
+  private
 
     def sol_titles
       ['English', 'History and Social Science', 'Mathematics', 'Science']
     end
 
-    def sols
-      @sols ||= select { |s| sol_titles.include?(s.title) }
+    def standards
+      @standards ||= get_attr(:standards).
+        sort_by { |s| s[:title] }.
+        collect do |raw_standard|
+          Standard.new(raw_standard.merge(:code => code, :edition => edition))
+        end
     end
 
-    def non_sols
-      @non_sols ||= reject { |s| sol_titles.include?(s.title) }
+    def path
+      "/courses/#{code},#{edition}/standards/"
     end
   end
 end

data/lib/verso/task.rb

@@ -1,30 +1,65 @@
 module Verso
-  class Task
-    include HTTPGet
+  # Task resource
+  #
+  # A {Verso::Course} task/competency contained by a {Verso::DutyArea} or
+  # a {Verso::CorrelationList}.
+  #
+  # @!attribute [r] code
+  #   @return [String] Course code
+  # @!attribute [r] definition
+  #   @return [String] HTML-formatted Task definition
+  # @!attribute [r] edition
+  #   @return [String] Course edition year
+  # @!attribute [r] id
+  #   @return [Fixnum] Task ID
+  # @!attribute [r] sensitive
+  #   @return [Boolean] Is this task sensitive?
+  # @!attribute [r] statement
+  #   @return [String] Task/competency statement
+  # @!attribute [r] questions
+  #   @return [String] HTML-formatted process/skill questions
+  #
+  # @overload initialize(attrs={})
+  #   @note Any attributes may be set upon instantiation, using Options Hash.
+  #     The following are required:
+  #   @option attrs [String] :code Course code *Required*
+  #   @option attrs [String] :edition Edition year *Required*
+  #   @option attrs [String] :id Task ID *Required*
+  class Task < Verso::Base
+    include HTTPGettable
+    attr_reader :code, :definition, :edition, :id, :sensitive, :statement,
+      :questions
+    alias sensitive? sensitive
 
-    def initialize(raw_task)
-      @raw_task = raw_task
-    end
-
-    def method_missing(mname)
-      if !@raw_task.has_key?(mname.to_s)
-        @raw_task.merge!(JSON.parse(
-          http_get("/courses/#{code},#{edition}/tasks/#{id}")
-        ))
-      end
-      @raw_task[mname.to_s]
+    # @return [Boolean] Does this task have only a statement?
+    def bare?
+      definition.empty? && standards.sols.empty?
     end
 
+    # @return [Boolean] Is this task considered essential?
     def essential
-      sensitive ? true : @raw_task["essential"]
+      sensitive ? true : get_attr(:essential)
     end
+    alias essential? essential
 
+    # @return [Verso::StandardsList] Standards related to this task
     def standards
-      @standards ||= StandardsList.new(goals)
+      # Yuck. Inject goals if we already have them, i.e. a correlation list.
+      # Otherwise, children will fetch resources and we get *all* the
+      # standards in the correlation lists.
+      raw_goals =  get_attr(:goals).collect do |k,v|
+                     v.merge(:name => k, :code => code, :edition => edition)
+                   end
+      @standards ||= StandardsList.new(
+        :code => code, :edition => edition, :standards => raw_goals
+      )
     end
+    alias goals standards
 
-    def bare?
-      definition.empty? && standards.sols.empty?
+  private
+
+    def path
+      "/courses/#{code},#{edition}/tasks/#{id}"
     end
   end
 end

data/lib/verso/task_list.rb

@@ -1,31 +1,54 @@
 module Verso
-  class TaskList
+  # Task List resource
+  #
+  # A collection of {Verso::DutyArea} objects containing the {Verso::Task}
+  # objects for a {Verso::Course}
+  #
+  # @see http://api.cteresource.org/docs/courses/course/tasks
+  #
+  # @!attribute [r] code
+  #   @return [String] Course code
+  # @!attribute [r] edition
+  #   @return [String] Course edition
+  #
+  # @overload initialize(attrs={})
+  #   @note Attributes required:
+  #   @option attrs [String] :code Course code *Required*
+  #   @option attrs [String] :edition Edition year *Required*
+  class TaskList < Verso::Base
     include Enumerable
-    include HTTPGet
-
-    attr_accessor :code, :edition
-
-    def initialize(params)
-      @code = params[:code]
-      @edition = params[:edition]
-    end
-
-    def duty_areas
-      @duty_areas ||= JSON.parse(
-        http_get("/courses/#{code},#{edition}/tasks/")
-      )["duty_areas"].to_a
-    end
+    include HTTPGettable
+    extend Forwardable
+    def_delegators :duty_areas, :[], :each, :empty?, :last, :length
+    attr_reader :code, :edition
 
+    # @return [Boolean] Contains non-essential tasks?
     def has_optional_task?
       any? { |da| da.tasks.any? { |t| !t.essential } }
     end
 
+    # @return [Boolean] Contains sensitive tasks?
     def has_sensitive_task?
       any? { |da| da.tasks.any? { |t| t.sensitive } }
     end
 
-    def each &block
-      duty_areas.each { |da| block.call(DutyArea.new(da, self)) }
+  private
+
+    def duty_areas
+      @duty_areas ||= begin
+                        get_attr(:duty_areas).
+                          collect do |da|
+                            DutyArea.new(
+                              da.merge!(:code => code, :edition => edition)
+                            )
+                          end
+                      rescue NameError
+                        []
+                      end
+    end
+
+    def path
+      "/courses/#{code},#{edition}/tasks/"
     end
   end
 end

data/lib/verso/version.rb

@@ -1,3 +1,3 @@
 module Verso
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end