clear-election-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35f1b77def83bb18cbc429b636a9bdcd1683ea30
+  data.tar.gz: 9f6136cec7c9af255eb48b92a36af5d16050957c
+SHA512:
+  metadata.gz: 0200ddc2529f35c99c1b47e165fa3653ee70904208f3f2e3da9416c8fdf0e4473d268e4d798411582c36e965de0dba497c220851a50dee3b7bf7182a43d53d43
+  data.tar.gz: c49ca30e6358a306db28619e82d4cf4b50061ae1785fb7b8b2434fafd0ea7d697a3077773560ea40bbef8f2bc9ab439defc9b722ff2673efbaa0b0c7701056dc

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.5

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+sudo: false
+rvm:
+- 2.1.5

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in clear_election.gemspec
+gemspec
+
+gem 'coveralls', require: false
+
+# for now use my forks in which warnings have been eliminated
+gem "timecop", git: 'https://github.com/ronen/timecop.git'          # PR is in https://github.com/travisjeffery/timecop/pull/131
+gem "addressable", git: 'https://github.com/ronen/addressable.git', branch: "patch-1"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ronen barzel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# ClearElection SDK (ruby)
+[![Gem Version](https://badge.fury.io/rb/clear-election-sdk.svg)](http://badge.fury.io/rb/clear-election-sdk)
+[![Build Status](https://secure.travis-ci.org/ClearElection/clear-election-sdk-ruby.svg)](http://travis-ci.org/ClearElection/clear-election-sdk-ruby)
+[![Coverage Status](https://img.shields.io/coveralls/ClearElection/clear-election-sdk-ruby.svg)](https://coveralls.io/r/ClearElection/clear-election-sdk-ruby)
+
+Ruby SDK to work with ClearElection data.
+
+
+## Overview
+
+Defines several classes:
+
+* `ClearElection::Election`
+* `ClearElection::Ballot`
+
+Defines a top-level function to retrieve an Election from a URI:
+
+	election = ClearElection.read(uri)
+
+Also includes utilities for testing application code that works with elections:
+
+	require 'clear-election-sdk/rspec'
+	require 'clear-election-sdk/factory'
+	
+For now, for more details UTSL.
+
+
+## Schemas
+
+For now, this repository contains the masters for the schemas.  Currently:
+
+* `schemas/election-0.0.schema.json` 
+* `schemas/ballot-0.0.schema.json`
+* `schemas/api/booth-agent-0.0.schema.json`
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'clear-election-sdk'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clear_election
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/clear_election/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+

data/clear-election-sdk.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clear-election-sdk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "clear-election-sdk"
+  spec.version       = ClearElection::VERSION
+  spec.authors       = ["ronen barzel"]
+  spec.email         = ["ronen@barzel.org"]
+  spec.summary       = %q{Ruby SDK for working with ClearElection data}
+  spec.description   = %q{Ruby SDK for working with ClearElection data.  Also includes factory and rspec helpers for testing apps}
+  spec.homepage      = "https://github.com/ClearElection/clear-election-sdk-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday"
+  spec.add_dependency "json-schema"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-gem-profile"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "timecop"
+end

data/lib/clear-election-sdk.rb

@@ -0,0 +1,17 @@
+require "faraday"
+require "json-schema"
+
+require "clear-election-sdk/ballot"
+require "clear-election-sdk/election"
+require "clear-election-sdk/schema"
+require "clear-election-sdk/version"
+
+module ClearElection
+
+  def self.read(uri)
+    response = Faraday.get(uri)
+    return nil unless response.success?
+    Election.from_json(JSON.parse(response.body), uri: uri)
+  end
+
+end

data/lib/clear-election-sdk/ballot.rb

@@ -0,0 +1,156 @@
+module ClearElection
+
+  class Ballot
+
+    SCHEMA_VERSION = 0.0
+
+    attr_reader :ballotId, :uniquifier, :contests, :errors, :demographic
+
+    def self.schema
+      ClearElection::Schema.ballot(version: SCHEMA_VERSION)
+    end
+
+    def self.from_json(data)
+      errors = JSON::Validator.fully_validate(schema, data, insert_defaults: true, errors_as_objects: true)
+      return self.new(ballotId: nil, uniquifier: nil, contests: [], errors: errors) unless errors.empty?
+
+      self.new(
+        ballotId: data["ballotId"],
+        uniquifier: data["uniquifier"],
+        contests: data["contests"].map { |data| Contest.from_json(data) },
+        demographic: data["demographic"]
+      )
+    end
+
+    def initialize(ballotId:, uniquifier:, contests:, errors: [], demographic: nil)
+      @ballotId = ballotId
+      @uniquifier = uniquifier
+      @contests = contests
+      @demographic = demographic
+      @errors = errors
+    end
+
+    def validate(election, complete: true)
+      @contests.each do |contest|
+        @errors += contest.validate(election)
+      end
+      if complete and not (missing = election.contests.map(&:contestId) - @contests.map(&:contestId)).empty?
+        @errors += missing.map { |contestId| { contestId: contestId, message: "missing contest" } }
+      end
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def as_json()
+      data = {
+        "version" => "0.0",
+        "ballotId" => @ballotId,
+        "uniquifier" => @uniquifier,
+        "contests" => @contests.map(&:as_json),
+      }
+      data["demographic"] = @demographic if @demographic
+      JSON::Validator.validate!(Ballot.schema, data)
+      data
+    end
+
+    def <=>(other)
+      [self.ballotId, self.contests] <=> [other.ballotId, other.contests]
+    end
+
+
+    class Contest
+
+      attr_reader :contestId, :choices
+
+      def initialize(contestId:, choices:)
+        @contestId = contestId
+        @choices = choices
+      end
+
+      def validate(election)
+        errors = []
+        err = { contestId: contestId }
+        contest = election.get_contest(contestId)
+        if contest.nil?
+          errors.push err.merge(message: "Invalid contest id")
+        else
+          if choices.length != contest.multiplicity
+            errors.push err.merge(message: "Invalid multiplicity", multiplicity: choices.length)
+          end
+          if contest.ranked and choices.map(&:rank).sort != (0...contest.multiplicity).to_a
+            errors.push err.merge(message: "Invalid ranking")
+          end
+          if choices.map(&:candidateId).uniq.length != choices.length
+            errors.push err.merge(message: "Duplicate choices")
+          end
+          choices.each do |choice|
+            case
+            when choice.writeIn?
+              if !contest.writeIn
+                errors.push err.merge(message: "Write-in not allowed")
+              end
+            when choice.candidate?
+              if !contest.candidates.map(&:candidateId).include?(choice.candidateId)
+                errors.push err.merge(message: "Invalid candidate id", candidateId: choice.candidateId)
+              end
+            end
+          end
+        end
+        errors
+      end
+
+      def <=>(other)
+        self.contestId <=> other.contestId
+      end
+
+      def self.from_json(data)
+        self.new(
+          contestId: data["contestId"],
+          choices: data["choices"].each_with_index.map{|data, i| Choice.from_json(data, rank: i)}
+        )
+      end
+
+      def as_json
+        {
+          "contestId" => @contestId,
+          "choices" => @choices.sort_by(&:rank).map(&:as_json)
+        }
+      end
+    end
+
+    class Choice
+      attr_reader :candidateId, :rank
+      def initialize(candidateId:, rank: nil)
+        @candidateId = candidateId
+        @rank = rank
+      end
+
+      def writeIn?
+        @candidateId.start_with?("WRITEIN:")
+      end
+
+      def abstain?
+        @candidateId == "ABSTAIN"
+      end
+
+      def candidate?
+        not (writeIn? or abstain?)
+      end
+
+      def self.from_json(data, rank: nil)
+        self.new(candidateId: data["candidateId"],
+                 rank: rank)
+      end
+
+      def as_json
+        {
+          "candidateId" => @candidateId
+        }
+      end
+    end
+
+
+  end
+end

data/lib/clear-election-sdk/election.rb

@@ -0,0 +1,150 @@
+module ClearElection
+
+  class Election
+
+    SCHEMA_VERSION = 0.0
+
+    attr_reader :signin, :booth, :pollsOpen, :pollsClose, :contests, :uri
+
+    def self.schema
+      ClearElection::Schema.election(version: SCHEMA_VERSION)
+    end
+
+    def initialize(name:, signin:, booth:, contests:, pollsOpen:, pollsClose:, uri:nil)
+      @name = name
+      @signin = signin
+      @booth = booth
+      @contests = contests
+      @pollsOpen = pollsOpen
+      @pollsClose = pollsClose
+      @uri = uri
+    end
+
+    def self.from_json(data, uri: nil)
+      JSON::Validator.validate!(schema, data, insert_defaults: true)
+      self.new(
+        name: data["name"],
+        signin: Agent.from_json(data["agents"]["signin"]),
+        booth: Agent.from_json(data["agents"]["booth"]),
+        contests: data["contests"].map {|data| Contest.from_json(data) },
+        pollsOpen: DateTime.rfc3339(data["schedule"]["pollsOpen"]),
+        pollsClose: DateTime.rfc3339(data["schedule"]["pollsClose"]),
+        uri: uri
+      )
+    end
+
+    def as_json()
+      data = {
+        "version" => "0.0",
+        "name" => @name,
+        "agents" => {
+          "signin" => @signin.as_json,
+          "booth" => @booth.as_json
+        },
+        "schedule" => {
+          "pollsOpen" => @pollsOpen.rfc3339,
+          "pollsClose" => @pollsClose.rfc3339,
+        },
+        "contests" => @contests.map(&:as_json)
+      }
+      JSON::Validator.validate!(Election.schema, data)
+      data
+    end
+
+    # utilities
+    def polls_have_not_opened?
+      DateTime.now < pollsOpen
+    end
+
+    def polls_are_now_open?
+      DateTime.now.between?(pollsOpen, pollsClose)
+    end
+
+    def polls_are_now_closed?
+      DateTime.now > pollsClose
+    end
+
+    def get_contest(contestId)
+      contests.find{|contest| contest.contestId == contestId}
+    end
+
+
+    class Agent
+      attr_reader :uri
+
+      def initialize(uri:)
+        @uri = URI(uri)
+      end
+
+      def self.from_json(data)
+        self.new(uri: data["uri"].sub(%r{/?$}, '/'))
+      end
+
+      def as_json()
+        {
+          "uri" => @uri.to_s
+        }
+      end
+
+    end
+
+    class Contest
+      attr_reader :contestId, :ranked, :multiplicity, :writeIn, :candidates
+
+      def initialize(contestId:, name:, ranked: nil, multiplicity: nil, writeIn: nil, candidates:)
+        @contestId = contestId
+        @name = name
+        @ranked = ranked || false
+        @multiplicity = multiplicity || 1
+        @writeIn = writeIn || false
+        @candidates = candidates
+      end
+
+      def self.from_json(data)
+        self.new(
+          contestId: data["contestId"],
+          name: data["name"],
+          ranked: data["ranked"],
+          multiplicity: data["multiplicity"],
+          writeIn: data["writeIn"],
+          candidates: data["candidates"].map {|data| Candidate.from_json(data)}
+        )
+      end
+
+      def as_json
+        {
+          "contestId" => @contestId,
+          "name" => @name,
+          "ranked" => @ranked,
+          "multiplicity" => @multiplicity,
+          "writeIn" => @writeIn,
+          "candidates" => @candidates.map(&:as_json)
+        }
+      end
+
+    end
+
+    class Candidate
+      attr_reader :candidateId
+
+      def initialize(candidateId:, name:)
+        @candidateId = candidateId
+        @name = name
+      end
+
+      def self.from_json(data)
+        self.new(
+          candidateId: data["candidateId"],
+          name: data["name"]
+        )
+      end
+
+      def as_json
+        {
+          "candidateId" => @candidateId,
+          "name" => @name
+        }
+      end
+    end
+  end
+end