verso 0.0.1

data/lib/verso/standards_list.rb

@@ -0,0 +1,49 @@
+module Verso
+  class StandardsList
+    include Enumerable
+
+    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) }
+    end
+
+    def each &block
+      standards.each &block
+    end
+
+    def last
+      standards[-1]
+    end
+
+    def empty?
+      standards.empty?
+    end
+
+    def sol_titles
+      ['English', 'History and Social Science', 'Mathematics', 'Science']
+    end
+
+    def sols
+      @sols ||= select { |s| sol_titles.include?(s.title) }
+    end
+
+    def non_sols
+      @non_sols ||= reject { |s| sol_titles.include?(s.title) }
+    end
+  end
+end

data/lib/verso/task.rb

@@ -0,0 +1,30 @@
+module Verso
+  class Task
+    include HTTPGet
+
+    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]
+    end
+
+    def essential
+      sensitive ? true : @raw_task["essential"]
+    end
+
+    def standards
+      @standards ||= StandardsList.new(goals)
+    end
+
+    def bare?
+      definition.empty? && standards.sols.empty?
+    end
+  end
+end

data/lib/verso/task_list.rb

@@ -0,0 +1,31 @@
+module Verso
+  class TaskList
+    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
+
+    def has_optional_task?
+      any? { |da| da.tasks.any? { |t| !t.essential } }
+    end
+
+    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)) }
+    end
+  end
+end

data/lib/verso/version.rb

@@ -0,0 +1,3 @@
+module Verso
+  VERSION = "0.0.1"
+end

data/spec/cluster_list_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Verso::ClusterList do
+  use_vcr_cassette :record => :new_episodes
+
+  it "responds to #first, #last" do
+    list = Verso::ClusterList.new
+    list.first.title.strip.should eq("Agriculture, Food and Natural Resources")
+    list.last.title.strip.
+      should eq("Transportation, Distribution and Logistics")
+  end
+end

data/spec/cluster_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Verso::Cluster do
+  before do
+    @pathway = { "title" => "Agribusiness Systems", "id" => 306 }
+    @raw_cluster = { "title" => "Information Technology",
+                     "pathways" => [@pathway] }
+    @cluster = Verso::Cluster.new(@raw_cluster)
+  end
+
+  it 'should respond to title' do
+    @cluster.title.should eq("Information Technology")
+  end
+
+  it 'should respond to pathways' do
+    @cluster.pathways.first.title.should eq("Agribusiness Systems")
+  end
+end

data/spec/correlation_list_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Verso::CorrelationList do
+  before do
+    @goal = OpenStruct.new({ "title" => "goal title",
+                             "description" => "goal description" })
+    @standard = double("Standard", :title => "standard title",
+                       :name => "standard_name",
+                       :description => "standard description",
+                       :goals => [@goal], :sections => [])
+    @standards_list = [@standard]
+    @standards_list.stub(:non_sols).
+      and_return([OpenStruct.new(:name => "standard_name"),
+                  OpenStruct.new(:name => "science")])
+    @task = double("Task", :statement => "task statement", :id => "111",
+                   :standards => @standards_list)
+    @tasks = [@task]
+    @duty_areas = [OpenStruct.new(:tasks => @tasks)]
+    @course = double("Course", :title => "course title", :edition => "1929",
+                     :code => "0000", :duration => 36, :hours => nil,
+                     :co_op => true, :related_resources => ["tasks"],
+                     :standards => @standards_list,
+                     :duty_areas => @duty_areas, :certifications => [])
+    correlations1 = { "correlations" => [
+      {"id" => "111", "statement" => "task statement",
+       "goals" => {
+         "standard_name" => { "title" => "English", "description" => "",
+                              "sections" => [],
+                              "goals" => [
+                                { "title" => "english goal title",
+                                  "description" => "english goal description" }
+                        ] }
+       }
+      }
+    ]}.to_json
+    @correlations = Verso::CorrelationList.new(@course, "standard_name")
+    Net::HTTP.stub(:get).and_return(correlations1)
+  end
+
+  it 'is enumerable' do
+    @correlations.first.statement.should eq('task statement')
+  end
+
+  it 'numbers the correlations' do
+    @correlations.first.number.should eq(1)
+  end
+
+  it 'has a goal' do
+    @correlations.first.standards.count.should_not eq(0)
+  end
+
+  it 'responds to #title' do
+    @correlations.title.should eq("standard title")
+  end
+end

data/spec/course_list_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Verso::CourseList do
+  use_vcr_cassette :record => :new_episodes
+
+  it "searches by text" do
+    results = Verso::CourseList.new(:text => "6321")
+    results.first.title.strip.should eq("Accounting, Advanced")
+  end
+
+  it "should return no results when query is empty" do
+    results = Verso::CourseList.new(:text => nil)
+    results.count.should == 0
+  end
+
+  it "searches by cluster" do
+    results = Verso::CourseList.new(:cluster => "education and training")
+    results.first.title.strip.
+      should eq("Equine Management Production")
+  end
+
+  it "can find courses by program area too" do
+    results = Verso::CourseList.new(:program_area => "across the board")
+    results.first.title.strip.should eq("Work-Based Learning through Service")
+  end
+
+  it "should return empty results when query is empty" do
+    Verso::CourseList.new({}).count.should == 0
+    [:text, :program_area, :cluster].each do |k|
+      Verso::CourseList.new(k => nil).count.should == 0
+      Verso::CourseList.new(k => '').count.should == 0
+    end
+    Verso::CourseList.new(:text => '', :program_area => '', :cluster => '').
+      count.should == 0
+  end
+end

data/spec/course_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Verso::Course do
+  before do
+    credentials = [{
+      "title" => "Certification 1", "type" => "Certification"
+    },
+      {"title" => "License 1", "type" => "License" }]
+    prerequisite_courses = [{
+      "code" => "2222", "hours" => nil, "duration" => 36,
+      "title" => "Basketweaving", "co_op" => true
+    }]
+    occupation_data = [{
+      "cluster" => { "title" => "Information Technology" },
+      "pathway" => { "title" => "Information and Support Services" },
+      "occupations" => [{ "title" => "Database Analyst" }]
+    }]
+    @extra = double("ExtrasList", :title => "Extra Title",
+                    :name => "extra_name")
+    @course = Verso::Course.new("code" => "6321", "duration" => 36,
+                         "title" => "Accounting, Advanced",
+                         "hours" => nil, "edition" => "2011",
+                         "co_op" => true,
+                         "related_resources" => ["extras"],
+                         "grade_levels" => "8 9 10",
+                         "credentials" => credentials,
+                         "occupation_data" => occupation_data,
+                         "related_courses" => prerequisite_courses,
+                         "prerequisite_courses" => prerequisite_courses)
+  end
+
+  it "responds to #extras" do
+    Verso::ExtrasList.should_receive(:new).and_return([@extra])
+    @course.extras.first.title.should eq("Extra Title")
+  end
+
+  it "responds to #related_courses" do
+    @course.related_courses.first.code.should eq('2222')
+  end
+
+  it "responds to #is_ms?" do
+    @course.is_ms?.should eq(true)
+  end
+
+  it "responds to #is_hs?" do
+    @course.is_hs?.should eq(true)
+  end
+
+  it "responds to #code" do
+    @course.code.should eq("6321")
+  end
+
+  it "responds to #duration" do
+    @course.duration.should eq(36)
+  end
+
+  it "responds to #title" do
+    @course.title.strip.should eq("Accounting, Advanced")
+  end
+
+  it "responds to #edition" do
+    @course.edition.should eq("2011")
+  end
+
+  it "responds to #hours" do
+    dental = Verso::Course.new("hours" => 280)
+    dental.hours.should eq(280)
+  end
+
+  it "responds to #co_op" do
+    @course.co_op.should eq(true)
+    Verso::Course.new("co_op" => false).co_op.should eq(false)
+  end
+
+  it "responds to #duty_areas" do
+    @task = double("Task", :statement => "a task", :id => "999999",
+                    :sensitive => false, :essential => true)
+    @duty_area = double("DutyArea", :title => "A Duty Area",
+                        :tasks => [@task])
+    Verso::TaskList.should_receive(:new).
+      with(:code => "6321", :edition => "2011").
+      and_return([@duty_area])
+    @course.duty_areas.first.should eq(@duty_area)
+  end
+
+  it "responds to #occupation_data" do
+    @occupation = double("Occupation", :title => "Database Analyst")
+    @pathway = double("Pathway", :title => "Information Support and Services")
+    @cluster = double("Cluster", :title => "Information Technology")
+    @occlist = double("OccupationData",
+                      :cluster => @cluster,
+                      :occupations => [@occupation],
+                      :pathway => @pathway)
+    Verso::OccupationData.should_receive(:new).and_return(@occlist)
+    @course.occupation_data.first.should eq(@occlist)
+  end
+
+  it "responds to prerequisites" do
+    @course.prerequisites.first.code.should eq('2222')
+  end
+
+  it "responds to credentials" do
+    @course.credentials.first.title.should eq("Certification 1")
+    @course.credentials.last.title.should eq("License 1")
+  end
+
+  it "responds to certifications" do
+    @course.certifications.first.title.should eq("Certification 1")
+    @course.certifications.count.should eq(1)
+  end
+
+  it "responds to licenses" do
+    @course.licenses.first.title.should eq("License 1")
+    @course.licenses.count.should eq(1)
+  end
+
+  it "responds to #standards" do
+    Verso::StandardsList.
+      should_receive(:from_course).
+      with(@course).
+      and_return(["phony"])
+    @course.stub(:method_missing).and_return(["standards"])
+    @course.standards.first.should eq("phony")
+  end
+
+  it "responds to #task" do
+    t = Verso::Task.new("code" => @course.code, "edition" => @course.edition,
+                        "id" => 99999999)
+    Verso::Task.should_receive(:new).
+      with("code" => @course.code,
+           "edition" => @course.edition,
+           "id" => 99999999).
+      and_return(t)
+    t = @course.task(99999999)
+    t.code.should eq(@course.code)
+  end
+
+  it "responds to #frontmatter" do
+    Verso::Frontmatter.should_receive(:new).
+      with("code" => @course.code,
+           "edition" => @course.edition).
+      and_return("phony")
+    @course.stub(:related_resources).and_return(["frontmatter"])
+    @course.frontmatter.should eq("phony")
+  end
+
+  it "#frontmatter returns nil if there is no frontmatter" do
+    @course.stub(:related_resources).and_return([])
+    @course.frontmatter.should eq(nil)
+  end
+
+  context "Only code and edition specified" do
+    use_vcr_cassette :record => :new_episodes
+
+    before do
+      @course = Verso::Course.new("code" => 6320, "edition" => "2011")
+    end
+
+    it "responds to #title" do
+      @course.title.should eq("Accounting")
+    end
+  end
+
+  context "MS-only course" do
+    before do
+      @course = Verso::Course.new("code" => "6320", "edition" => "2011",
+                           "grade_levels" => "8")
+    end
+
+    it 'knows it is ms' do
+      @course.is_ms?.should eq(true)
+    end
+
+    it 'knows it is not hs' do
+      @course.is_hs?.should eq(false)
+    end
+  end
+
+  context 'HS-only course' do
+    before do
+      @course = Verso::Course.new("code" => "6320", "edition" => "2011",
+                           "grade_levels" => "10")
+    end
+
+    it 'knows it is not ms' do
+      @course.is_ms?.should eq(false)
+    end
+
+    it 'knows it is hs' do
+      @course.is_hs?.should eq(true)
+    end
+  end
+end

data/spec/credential_list_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Verso::CredentialList do
+  context "complete list" do
+    before do
+      Net::HTTP.
+        should_receive(:get).
+        with('api.cteresource.org', "/credentials", 80).
+        and_return(
+          JSON.pretty_generate(
+            :credentials => [ { :type => "Certification",
+                              :source => { :title => "NOCTI" },
+                              :title => "Business Financial Management",
+                              :id => 845 } ]
+          )
+        )
+      @credentials = Verso::CredentialList.new
+    end
+
+    it 'responds to #first' do
+      credential = @credentials.first
+      credential.title.should eq("Business Financial Management")
+      credential.id.should eq(845)
+    end
+
+    it 'responds to #last' do
+      credential = @credentials.last
+      credential.title.should eq("Business Financial Management")
+      credential.id.should eq(845)
+    end
+
+    it 'responds to #empty?' do
+      @credentials.empty?.should eq(false)
+    end
+  end
+
+  context "search list" do
+    before do
+      Net::HTTP.
+        should_receive(:get).
+        with('api.cteresource.org', "/credentials?text=nocti", 80).
+        and_return(
+          JSON.pretty_generate(
+            :credentials => [ { :type => "Certification",
+                              :source => { :title => "NOCTI" },
+                              :title => "Basket weaving",
+                              :id => 855 } ]
+          )
+        )
+      @credentials = Verso::CredentialList.new(:text => 'nocti')
+    end
+
+    it 'searches credentials' do
+      credential = @credentials.first
+      credential.title.should eq("Basket weaving")
+      credential.id.should eq(855)
+    end
+  end
+
+  context "search list with empty string" do
+    before do
+      Net::HTTP.
+        should_receive(:get).
+        with('api.cteresource.org', "/credentials", 80).
+        and_return(
+          JSON.pretty_generate(:credentials => [])
+        )
+      @credentials = Verso::CredentialList.new(:text => '')
+    end
+
+    it 'searches credentials' do
+      @credentials.empty?
+    end
+  end
+end