mirador 0.0.4 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Zjc0NzZjMDljNTNiZjlhNTlhMDlhZGZmYjg1NjRjZmEzZDFiZWU2MA==
+    MGZmMTU1ODJkZDdiZjM3MmQ1NzA1MjJkNjkxMjUxMzM1MmMyOTQ1Yg==
   data.tar.gz: !binary |-
-    NTg0ZDE2NzYwNmVjOTVhNmU2MDYzMzljODhiNWQzYzE2NTA4NjNhNg==
+    OWYyNjc4N2EzMWU1Mjc4YWUxMWJmOGU4NjNhMmFkZjRiZWUzYWYwMA==
 SHA512:
   metadata.gz: !binary |-
-    Nzg1NDIxOWExZWFjZjQ5YTg3M2YxN2IyYmMyYjZjOGI5MTQ2ODdkYWRhOTJk
-    NzYzMTQ3MjU4ZWVkNjU5NTlhZjg0ZWIwNDhkNjhkOWFjZTkwOTk0YTlhZTE4
-    MjRmNzc1NmQyZTAzNGMwMTUwN2E4MmU4NmU4ZGQwYjc2YzE4OWM=
+    Mjk2MWU1MDM2ZmNiZDUyYTMwMTRlNzIyMTMyZWY5ZDg5ZDdmNGZhM2FhNDlk
+    MDk5MmQ4Nzg3MTI1MjE2ODM1MDY4MjU5YzEzNjAyZmRhYTEwYThmMjI2MTVj
+    Mjk1N2IxMGIyNzdhMmQxY2IyN2U3ZGQxZGQxOGRlZmI2ZDAyNDU=
   data.tar.gz: !binary |-
-    YzBhODExNjc5OWE2N2E2OThjNDBjOTIwNmJiYjE3ZThlNTBjNzMyMGZiZjFi
-    ZWRkMjhmOWVhYWY1ZGRkNzhjNTViNWNiNDgwMGUzMTgxZDRiNzNiZDE2MWM3
-    MzY4NDlmMmVjYmRjOTM1NTUxYTRlMzQ4NDM3ZDQ5NjYxMzJmMDM=
+    Yzg0NDBiNTgwODg2MjRlMGVmZTUzNzQ1ZDQ1NTE0ZDhlZTE5MzYxMjhjNTQ0
+    MDVkNzFhZGIwNjU5NGQyMmY1MTBhN2RiZmM1MjU0MTJkYTYwNTNmY2EyZjE0
+    MmZkNGJmMmY0YzhkZTkwZjgzMjY4ZmFmNjdlNzYzMjdmNDBiNmU=

data/README.md

@@ -18,42 +18,257 @@ Or install it yourself as:
 
 ## Usage
 
-There are really two basic methods available on the API. To get started, you need an API key, available from [mirador.im/join](http://mirador.im/join). If you have problems with the API or this client, please contact support@mirador.im.
+To get started, you need an API key, available from [mirador.im/join](http://mirador.im/). If you have problems with the API or this client, please contact support@mirador.im.
 
-### `Mirador::Client.classify_files(files) -> [Mirador::Result]`
+## Mirador::Result and Mirador::ResultList
 
-This method takes a list of filenames and returns a list of `Mirador::Result` objects. See example:
+All multiple-request methods (e.g., classify_files), return a [Mirador::ResultList](#resultlist), which is effectively a list of Mirador::Result objects; single-request methods (e.g., classify_url) return a [Mirador::Result](#result) object.
+
+## Classifying Files & Buffers
+
+You can classify 4 types of files/file-objects:
+
+* file objects (e.g., `x` where `x = File.open('myfile.jpg')`); [classify_files](#classify_files)
+* filenames `myfile.jpg` [classify_files](#classify_files)
+* buffers `buffer = File.read('myfile.jpg')` [classify_buffers](#classify_buffers)
+* base64-encoded buffers (e.g., from a data URI) [classify_encoded_strings](#classify_encoded_strings)
+
+The methods for file-based classification are as follows:
+
+
+### <a name="classify_files"></a> Mirador::Client#classify_files
 
 ```ruby
 require 'mirador'
+mc = Mirador::Client.new('your_api_key')
+
+results = mc.classify_files('test.jpg', 'picture.jpg')
 
-mc = Mirador::Client.new('your_key_here')
-mc.classify_files('bathing-suit.jpg', 'nsfw-user-upload.png').each do |result|
-  puts "name: #{ result.name }, safe: #{ result.safe }, value: #{ result.value }"
+assert results['test.jpg']
+assert_equal results.length, 2
+
+results.each do |res|
+  puts "#{ res.id }, #{ res.value }"
+end
+
+results.each do |id, res|
+  puts "#{ id }, #{ res.value }"
 end
 
 ```
 
-### `Mirdor::Client.classify_urls(urls) -> [Mirador::Result]`
+You can also specify an id to be used:
+
+```ruby
+require 'mirador'
+mc = Mirador::Client.new 'your_api_key'
+
+# first method: use ids as keys
+results = mc.classify_files(nsfw: 'nsfw.jpg', sfw: 'sfw.jpg')
 
-This method takes a list of urls and returns `Mirador::Result` objects. Identical to `classify_files`:
+assert results[:nsfw]
+assert results[:sfw]
+
+# second method: pass an array of { id:, data: } hashes
+results = mc.classify_files([{ id: :nsfw, data: 'nsfw.jpg'}, { id: :sfw, data: 'sfw.jpg' }])
+
+assert results[:nsfw]
+assert results[:sfw]
+```
+
+File can be either a filename or a file object; e.g., the following is also valid:
+
+```ruby
+results = mc.classify_files(nsfw: File.open('nsfw.jpg'))
+```
+
+### <a name='classify_file'></a> Mirador::Client#classify_file
+
+A shortcut for classifying a single file; this will return a `Mirador::Result` instead of a `Mirador::ResultList`:
 
 ```ruby
 require 'mirador'
+mc = Mirador::Client.new 'your_api_key'
 
-mc.classify_urls('http://possibly-nsfw.com/cool.png', 'http://mysite.net/image/bad-picture.jpg').each do |result|
-  puts "name: #{ result.name }, safe: #{ result.safe }, value: #{ result.value }"
-end
+# first method: use ids as keys
+nsfw = mc.classify_file(nsfw: 'nsfw.jpg')
 
+puts nsfw.value
 ```
 
-### `Mirador::Result`
+### <a name='classify_buffers'></a> Mirador:Client#classify_buffers
+
+Classify a buffer, e.g., an already-read file. This simplifies the classification of file uploads, e.g. POST data. The interface is identical to [classify_files](#classify_files), only differing in the actual data passed in:
+
+```ruby
+require 'mirador'
+mc = Mirador::Client.new 'your_api_key'
+
+nsfw_buf = File.read('nsfw.jpg')
+sfw_buf = File.read('sfw.jpg')
+
+# these are equivalent
+results = mc.classify_buffers(nsfw: nsfw_buf, sfw: sfw_buf)
+results = mc.classify_buffers([{id: :nsfw, data: nsfw_buf}, {id: :sfw, data: sfw_buf}])
+
+# since buffers dont have a name, you just get an index as id
+results = mc.classify_buffers(nsfw_buf, sfw_buf)
+```
+
+#### <a name='classify_buffer'></a> Mirador::Client#classify_buffer
+
+As with classify_file, there is a shortcut for classifying only one buffer; see [classify_file](#classify_file) for clarifications on usage (it's identical).
+
+### <a name='classify_encoded_strings'></a> Mirador::Client#classify_encoded_strings
+
+The Mirador API internally represents images as base64-encoded strings (agnostic of image encoding); this method lets you pass in an alread-encoded string in the event that you're also using base64 encoding elsewhere in your system. Usage is the same as [classify_buffers](#classify_buffers):
+
+```ruby
+require 'mirador'
+require 'base64'
+
+mc = Mirador::Client.new 'your_api_key'
+
+nsfw_buf = Base64.encode64(File.read('nsfw.jpg'))
+sfw_buf = Base64.encode64(File.read('sfw.jpg'))
+
+# these are equivalent
+results = mc.classify_encoded_strings(nsfw: nsfw_buf, sfw: sfw_buf)
+results = mc.classify_encoded_strings([{id: :nsfw, data: nsfw_buf}, {id: :sfw, data: sfw_buf}])
+
+# since strings dont have a name, you just get an index as id
+results = mc.classify_encoded_strings(nsfw_buf, sfw_buf)
+```
+
+#### <a name='classify_encoded_string'></a> Mirador::Client#classify_encoded_string
+
+Another helper for only working with 1 request/result at a time. See [classify_file](#classify_file) for more info.
+
+
+### <a name='classify_data_uris'></a> Mirador::Client#classify_data_uris
+
+This simplifies data transfer between client applications and the mirador API. For example, given the following javascript:
+
+```javascript
+document.getElementById('form-field').addEventListener('change', function (e) {
+
+  var file = this.files[0];
+
+  var reader = new FileReader();
+  reader.onload = function (e) {
+    $.post('/proxy/mirador', { id: file.name, data: e.target.result });
+  }
+
+  reader.readAsDataURL(file);
+});
+```
+
+Your could classify that data url with the following code:
+
+```ruby
+
+res = mc.classify_data_uris(request['id'] => request['data'])
+
+# send the result
+res[request['id']].to_json
+
+# or, even easier
+mc.classify_data_uri(request['id'] => request['data']).to_json
+
+```
+
+Otherwise, classify_data_uris and classify_data_uri have identical interfaces to the other methods covered so far.
+
+
+## Classify URLs
+
+You can easily classify a publically-available URL (e.g., a public s3 bucket), with [classify_urls](#classify_urls) and [classify_url](#classify_url). The interfaces for these methods are identical to the file-handling methods covered above.
+
+
+### <a name='classify_urls'></a> Mirador::Client#classify_urls
+
+The only things to keep in mind with URLs:
+
+* must be publically-accessibly
+* must be < Mirador::Client::MAX_ID_LEN if you are using the url as the item's id (see below)
+* download/response time on url will affect response time of result, must be less than 60 seconds.
+
+
+#### Examples:
+
+
+Assigning specific ids to urls:
+
+```ruby
+require 'mirador'
+
+mc = Mirador::Client.new 'your_api_key'
+
+res = mc.classify_urls(nsfw: 'http://static.mirador.im/test/nsfw.jpg', sfw: 'http://static.mirador.im/test/sfw.jpg')
+
+assert res[:nsfw]
+assert res[:sfw].safe
+
+```
+
+Implicitly using url as its own id:
+
+```ruby
+require 'mirador'
+
+nsfw_url = 'http://static.mirador.im/test/nsfw.jpg'
+sfw_url = 'http://static.mirador.im/test/sfw.jpg'
+
+mc = Mirador::Client.new 'your_api_key'
+res = mc.classify_urls(nsfw_url, sfw_url)
+
+puts res[nsfw_url].value
+puts res[sfw_url].value
+```
+
+Classify a single URL using Mirador::Client#classify_url
+
+```ruby
+require 'mirador'
+
+mc = Mirador::Client.new 'your_api_key'
+nsfw = mc.classify_url(nsfw_url)
+
+assert (not nsfw.safe)
+puts nsfw.value
+```
+
+## <a name='result'></a> Mirador::Result
+
+The `Mirador::Result` class wraps the output of the API for a specific image/url. It has the following attributes:
+
+* `@id` [Mixed]: the id, as specified in the request, or implied (see above)
+* `@safe` [Boolean]: whether the image should be considered flagged/containing adult content
+* `@value` [Float 0.0-1.0]: A float indicating the likelyhood of the image containing adult content (useful for creating custom thresholds)
+* `@error` [String]: will only be non-nil if this is an error
+
+The `Mirador::Result` object also has a couple of convenience methods:
+
+* `#to_h` - convert to a hash
+* `#to_json` - if json is require'd, serialize to json
+* `#failed?` - returns a boolean indicating whether image is a failure/error
+* `#to_s` - returns a string representation of the result`
+* `#name` **(deprecated)** - this simply maps to `@id`
+
+## <a name='resultlist'></a> Mirador::ResultList [Enumerable]
+
+Methods that return multiple results do so by returning a single `Mirador::ResultList`. This object is used in lieu of a Hash or Array as to provide mixed-access. You can treat it as an array, iterating via `each do |x|`, indexing with integers, or by simply calling `#to_a`, or as a hash, indexing with `@id`'s from image-requests.
+
+The ResultList has the following methods:
 
-The `Mirador::Result` class has 3 fields:
+* `#[](key)` operator override to index the ResultList. You can index by integers in range of 0 - ResultList#length, or by an `@id` for one of the Result objects within.
+* `#to_a` convert to an array of `Mirador::Result` objects
+* `#length` the number of items in the `ResultList`
+* `#update` equivalent to Hash#update
+* `#to_h` conver to a hash
+* `#to_json` serialize the resultlist as json
+* `#each` `ResultList` includes `Enumerable`, and this implementation of `#each` checks the arity of blocks passed in to allow iteration either as an array or as a Hash.
 
-* `Result.name` - `string`, the filename or url for this request
-* `Result.safe` - `bool`, a boolean indicating whether image contains adult content.
-* `Result.value` - `float`, a number 0.0 - 1.0 indicating confidence of judgement
 
 ## Contributing
 

data/lib/mirador.rb

@@ -3,137 +3,343 @@ require 'base64'
 
 module Mirador
 
-  API_BASE = "http://api.mirador.im/v1/"
+  class ApiError < StandardError
+  end
 
-  class Result
-    attr_accessor :name, :safe, :value
+  class ResultList
+    include Enumerable
+
+    def initialize(items=[])
+      @items = {}
 
-    def initialize name, data
-      @name = name
-      @safe = data['safe']
-      @value = data['value']
+      items.each do |x|
+        @items[x.id] = x
+      end
     end
 
-    def to_s
-      "<Mirador::Result; name: #{ @name }; safe: #{ @safe }; value: #{ @value }/>"
+    def <<(item)
+      @items[item.id] = item
+    end
+
+    def [](key)
+      if key.is_a? Integer and not @items.has_key? key
+        @items.values[key]
+      else
+        @items[key.to_s]
+      end
+    end
+
+    def to_a
+      @items.values
+    end
+
+    def length
+      @items.values.length
     end
 
-    def self.parse_results reqs, results
+    def update other
+      @items.update(other)
+    end
+
+    def to_h
+      @items
+    end
 
-      if not results
-        raise ApiError, "no results for: #{ reqs }"
+    def to_json
+      @items.to_json
+    end
+
+    def each &block
+      if block.arity == 1
+        @items.values.each do |x|
+          block.call(x)
+        end
+      else
+        @items.each do |k, v|
+          block.call(k, v)
+        end
       end
+    end
+
+    def self.parse_results res
 
-      results.each_with_index.map do |v, i|
-        Result.new(reqs[i], v['result'])
+      output = {}
+      res.each do |x|
+        r = Result.new(x)
+        output[r.id] = r
       end
+
+      output
     end
 
   end
 
-  class ApiError < StandardError
+  class Result
+    attr_accessor :id, :safe, :value, :error
+
+    def initialize data
+
+      if data.has_key? 'errors'
+        @error = data['errors']
+        return
+      end
+
+      @id = data['id']
+      @safe = data['result']['safe']
+      @value = data['result']['value']
+
+    end
+
+    def to_h
+      {
+        id: @id,
+        safe: @safe,
+        value: @value,
+      }
+    end
+
+    def to_json
+      as_h = self.to_h
+
+      if as_h.respond_to? :to_json
+        as_h.to_json
+      else
+        nil
+      end
+    end
+
+    def failed?
+      @error != nil
+    end
+
+    def to_s
+      "<Mirador::Result; id: #{ @id }; safe: #{ @safe }; value: #{ @value }/>"
+    end
+
+    def name
+      @id
+    end
+
   end
 
   class Client
     include HTTParty
     base_uri 'api.mirador.im'
+
     default_timeout 10
 
-    MAX_LEN = 8
+    MAX_LEN = 5
+    MAX_ID_LEN = 256
+    DATA_URI_PRE = ';base64,'
+    DATA_URI_PRELEN = 8
 
     def initialize(api_key)
       @options = { api_key: api_key }
     end
 
-    def classify_urls urls
-
-      if urls.length > MAX_LEN
-        out = []
-        urls.each_slice(MAX_LEN) do |s|
-          out << self.classify_urls(s)
+    # metaprogramming extreme
+    [:url, :file, :buffer, :encoded_string, :data_uri].each do |datatype|
+      define_method("classify_#{datatype.to_s}s") do |args, params={}|
+        flexible_request args, params do |item|
+          fmt_items(datatype, item)
         end
+      end
 
-        return out.flatten
+      define_method("classify_#{datatype.to_s}") do |args, params={}|
+        res = self.send("classify_#{datatype.to_s}s", args, params)
+        res[0]
       end
 
-      res = self.class.post(
-        "/v1/classify",
-        {
-          body: @options.merge({url: urls}),
-          headers: {"User-Agent" => "Mirador Client v1.0/Ruby"}
-        }
-      )
+    end
 
-      if res['errors']
-        raise ApiError, res['errors']
-      elsif not res
-        raise ApiError, "no response: #{ res.code }"
-      end
+    protected
+
+    def flexible_request(args, params={}, &cb)
+      req = {}
+
+      req = (if args.is_a? Hash
+
+        Hash[args.map do |k, v|
+          process_param(k, v)
+        end]
+
+      elsif args.is_a? String
+        Hash[[process_argument(args)]]
+
+      elsif args and args.length
+        Hash[args.each_with_index.map do |a, idx|
+          process_argument(a, idx)
+        end]
 
-      return Result.parse_results urls, res['results']
+      elsif params
+        Hash[params.map do |k, v|
+          process_param(k, v)
+        end]
+      end)
+
+      chunked_request(req) do |item|
+        formatted = cb.call(item)
+        make_request(formatted)
+      end
     end
 
-    def classify_files files
-      if files.length > MAX_LEN
-        out = []
-        files.each_slice(MAX_LEN) do |s|
-          out << self.classify_files(s)
+    def process_argument arg, idx=0
+
+      if arg.is_a?(String) 
+        if arg.length < MAX_ID_LEN
+          [arg,  arg]
+        else
+          [idx, arg]
         end
 
-        return out.flatten
-      end
+      elsif arg.respond_to?(:name) and arg.respond_to?(:read)
 
-      processed = files.map do |f| self.process_file(f) end
-      return self.classify_encoded files, processed
-    end
+        [arg.name, arg]
+
+      elsif arg.respond_to?(:id) and arg.respond_to?(:data)
 
+        [arg.id, arg.data]
 
-    def classify_raw_images imgs
+      elsif arg.is_a?(Hash)
 
-      if imgs.length > MAX_LEN
-        out = []
-        imgs.each_slice(MAX_LEN) do |s|
-          out << self.classify_raw_images(Hash[s])
+        if arg.has_key? :id and arg.has_key? :data
+          [arg[:id], arg[:data]]
+        elsif arg.has_key? 'id' and arg.has_key? 'data'
+          [arg['id'], arg['data']]
         end
 
-        return out.flatten
+      else
+        raise ApiError, "Invalid argument: #{ arg }"
       end
 
-      # expects a hash
-      # id => image
-      images, names = [], []
-      imgs.each_pair do |k, v|
-        images << v
-        names << k
+    end
+
+    # given a parameter passed in,
+    # assuming that its a id => data mapping, return
+    # the correct formatting/check for any fuck ups
+    # @arguments:
+    #   k - key
+    #   v - value
+    # @returns:
+    #   { k => v } pair
+    def process_param k, v
+
+      if v.is_a?(File)
+        [ k, v.read ]
+      elsif k.respond_to?(:to_s) and v.is_a?(String)
+        [ k.to_s, v ]
+      else
+        raise ApiError, "Invalid Argument: #{ k } => #{ v }"
+      end
+
+    end
+
+    # given a request and a block,
+    # call the block X number of times
+    # where X is request.length / MAX_LEN
+    def chunked_request req, &mthd
+      output = ResultList.new
+      req.each_slice(MAX_LEN).each do |slice|
+        output.update(mthd.call(slice))
       end
 
-      processed = images.map { |i| Base64.encode64(i).gsub("\n", '') }
-      return self.classify_encoded names, processed
+      return output
     end
 
-    def process_file file
-      data = File.read(file)
-      Base64.encode64(data).gsub("\n", '')
+    # basically, transform hash h into a hash
+    # where the key-value pairs are all formatted
+    # by 'fmt-item' (should double the number of key-value
+    # pairs in the hash)
+    def fmt_items name, h
+      out = {}
+      h.each_with_index do |kv, idx|
+        out.update fmt_item(name, idx, kv[0], kv[1])
+      end
+      return out
     end
 
-    def classify_encoded files, encoded
+    @@name_map = {
+      file: 'image',
+      buffer: 'image',
+      raw: 'image',
+      url: 'url',
+      encoded_string: 'image',
+      data_uri: 'image',
+    }
+
+    @@formatters = {
+      url: Proc.new { |url| url },
+
+      file: Proc.new { |file|
+
+        Base64.encode64(if file.respond_to? :read
+          file.read
+        else
+          File.read(file)
+        end).gsub(/\n/, '')
+
+      },
+
+      buffer: Proc.new { |file|
+
+        Base64.encode64(file).gsub(/\n/, '')
+
+      },
+
+      raw: Proc.new { |file|
+
+        Base64.encode64(file).gsub(/\n/, '')
+
+      },
+
+      encoded_string: Proc.new { |b64str|
+        b64str.gsub(/\n/, '')
+      },
+
+      data_uri: Proc.new { |datauri|
+        datauri.sub(/^.+;base64,/, '').gsub(/\n/,'')
+      },
+
+    }
+
+    # produce a k-v mapping internal to the API,
+    # so that 'name' is the datatype: 
+    # e.g., name[idx][id], name[idx][data]
+    def fmt_item name, idx, id, data
+      formatted = @@formatters[name].call(data)
+      datatype = @@name_map[name]
+      {
+        "#{datatype}[#{idx}][id]" => id,
+        "#{datatype}[#{idx}][data]" => formatted,
+      }
+    end
+
+    # base method to actually make the request
+    def make_request params
+
       res = self.class.post(
         "/v1/classify",
         {
-          body: @options.merge({image: encoded}),
-          headers: {'User-Agent' => 'Mirador Client v1.0/Ruby'},
+          body: @options.merge(params),
+          headers: {"User-Agent" => "Mirador Client v1.0/Ruby"}
         }
       )
 
+      k = 'results'
+
       if res['errors']
-        raise ApiError, res['errors']
-      end
 
-      if not res
-        raise ApiError, "no response", res.code
+        if not res['result']
+          raise ApiError, res
+        else
+          k = 'result'
+        end
+
+      elsif not res
+        raise ApiError, "no response: #{ res.code }"
       end
 
-      return Result.parse_results(files, res['results'])
+      return ResultList.parse_results res[k]
     end
 
   end

data/lib/mirador/version.rb

@@ -1,3 +1,3 @@
 module Mirador
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/test/test_mirador.rb

@@ -1,5 +1,6 @@
 require 'test/unit'
-require 'mirador'
+require './lib/mirador'
+require 'base64'
 
 class MiradorTest < Test::Unit::TestCase
 
@@ -11,15 +12,14 @@ class MiradorTest < Test::Unit::TestCase
   SFW_URL = "http://demo.mirador.im/test/sfw.jpg"
   NSFW_URL = "http://demo.mirador.im/test/nsfw.jpg"
 
-  MM = Mirador::Client.new('')
+  MM = Mirador::Client.new(ENV['MIRADOR_API_KEY'])
 
   def test_classify_files
 
     res = MM.classify_files([NSFW_IM, SFW_IM])
-
     assert_equal res.length, 2
 
-    nsfw, sfw = res
+    nsfw, sfw = res[NSFW_IM], res[SFW_IM]
 
     assert_operator nsfw.value, :>=, 0.50
     assert_operator sfw.value, :<, 0.50
@@ -27,92 +27,147 @@ class MiradorTest < Test::Unit::TestCase
     assert nsfw.name.eql?(NSFW_IM), "nsfw name does not match"
     assert sfw.name.eql?(SFW_IM), "sfw name does not match"
 
+    assert nsfw.id.eql?(NSFW_IM)
+    assert sfw.id.eql?(SFW_IM)
+
     assert sfw.safe
     assert (not nsfw.safe)
 
   end
 
-  def test_chunked_files
-    nsfw_files = [NSFW_IM]*10
-    sfw_files = [SFW_IM]*10
+  def test_classify_urls
 
-    nres = MM.classify_files(nsfw_files)
-    assert_equal nres.length, 10
+    res = MM.classify_urls([NSFW_URL, SFW_URL])
+    assert_equal 2, res.length
 
-    nres.each do |r|
-      assert_operator r.value, :>=, 0.50
-      assert r.name.eql?(NSFW_IM)
-      assert (not r.safe)
-    end
+    nsfw, sfw = res[NSFW_URL], res[SFW_URL]
 
-    sres = MM.classify_files(sfw_files)
-    assert_equal sres.length, 10
+    assert_operator nsfw.value, :>=, 0.50
+    assert_operator sfw.value, :<, 0.50
+
+    assert nsfw.name.eql?(NSFW_URL), "nsfw name does not match"
+    assert sfw.name.eql?(SFW_URL), "sfw name does not match"
+
+    assert nsfw.id.eql?(NSFW_URL)
+    assert sfw.id.eql?(SFW_URL)
+
+    assert sfw.safe
+    assert (not nsfw.safe)
 
-    sres.each do |r|
-      assert_operator r.value, :<, 0.50
-      assert r.name.eql?(SFW_IM)
-      assert r.safe
-    end
   end
 
-  def test_chunked_urls
-    nsfw_urls = [NSFW_URL]*10
-    sfw_urls = [SFW_URL]*10
+  def test_classify_chunked_urls
 
-    nres = MM.classify_urls(nsfw_urls)
-    assert_equal nres.length, 10
+    r = Hash[([NSFW_URL]*10).each_with_index.map do |url, idx|
+      [ "#{ idx }-im", url ]
+    end]
 
-    nres.each do |r|
-      assert_not_nil r
-      assert_operator r.value, :>=, 0.50
-      assert r.name.eql?(NSFW_URL)
-      assert (not r.safe)
-    end
+    res = MM.classify_urls(r)
 
-    sres = MM.classify_urls(sfw_urls)
-    assert_equal sres.length, 10
+    assert_equal 10, res.length
 
-    sres.each do |r|
-      assert_not_nil r
-      assert_not_nil r.value
-      assert_operator r.value, :<, 0.50
-      assert r.name.eql?(SFW_URL)
-      assert r.safe
+    res.each do |id, r|
+      assert_operator r.value, :>=, 0.50
     end
 
   end
 
-  def test_classify_urls
-    res = MM.classify_urls([NSFW_URL, SFW_URL])
+  def test_hash_call
 
-    assert_equal res.length, 2
-    nsfw, sfw = res
+    res = MM.classify_urls(nsfw: NSFW_URL, sfw: SFW_URL)
+
+    assert res[:nsfw]
+    assert res[:sfw]
 
-    assert nsfw.name.eql?(NSFW_URL)
-    assert sfw.name.eql?(SFW_URL)
+    nsfw = res[:nsfw]
+    sfw = res[:sfw]
 
     assert_operator nsfw.value, :>=, 0.50
     assert_operator sfw.value, :<, 0.50
 
+    assert nsfw.name.eql?('nsfw'), "nsfw name does not match"
+    assert sfw.name.eql?('sfw'), "sfw name does not match"
+
+    assert nsfw.id.eql?('nsfw')
+    assert sfw.id.eql?('sfw')
+
     assert sfw.safe
     assert (not nsfw.safe)
+
   end
 
-  def test_classify_raw
-    nsfw_d, sfw_d = [NSFW_IM, SFW_IM].map { |f| File.read(f) }
-    res = MM.classify_raw_images({ "nsfw" => nsfw_d, "sfw" => sfw_d })
+  def test_single_url
+
+    res = MM.classify_url(nsfw: NSFW_URL)
+    res1 = MM.classify_url(NSFW_URL)
+
+    assert_equal res.value, res1.value
+
+  end
+
+  def test_items_call
+
+    res = MM.classify_urls([{ id: :nsfw, data: NSFW_URL }, { id: :sfw, data: SFW_URL }])
 
     assert_equal res.length, 2
-    nsfw, sfw = res
 
-    assert nsfw.name.eql?('nsfw'), "invalid name: #{ nsfw.name }"
-    assert sfw.name.eql?('sfw')
+    assert res[:nsfw]
+    assert res[:sfw]
 
-    assert_operator nsfw.value, :>=, 0.50
-    assert_operator sfw.value, :<, 0.50
+  end
+
+  def test_classify_buffers
+
+    bufs = Hash[([File.read(NSFW_IM)]*3).each_with_index.map do |b, idx|
+      ["#{idx}-buf", b]
+    end]
+
+
+    res = MM.classify_buffers(bufs)
+
+    res1 = MM.classify_buffer(File.read(SFW_IM))
+
+    assert_equal res.length, 3
+    assert_operator res1.value, :<=, 0.50
+
+    res.each do |r|
+      assert_operator r.value, :>=, 0.5
+    end
+  end
+
+  def test_data_uris
+    duri = 'data:image/jpg;base64,' + Base64.encode64(File.read(NSFW_IM)).gsub(/\n/, '')
+
+    res = MM.classify_data_uris(nsfw: duri)
+
+    assert res[:nsfw]
+    assert_operator res[:nsfw].value, :>=, 0.50
+  end
+
+  def test_encoded_string
+
+    tdata = Hash[[SFW_IM, NSFW_IM].map do |fname|
+      [fname, Base64.encode64(File.read(fname))]
+    end]
+
+    res = MM.classify_encoded_strings(tdata)
+
+    assert res[SFW_IM]
+    assert res[NSFW_IM]
+
+    assert_operator res[NSFW_IM].value, :>=, 0.50
+
+  end
+
+  def test_item_error
+
+    res = MM.classify_urls([{ id: :nsfw, data: 'invalid-url'}, { id: :sfw, data: SFW_URL }])
+
+    assert_equal res.length, 2
+    assert res[:sfw]
+
+    assert res.any? do |r| r.failed? end
 
-    assert sfw.safe
-    assert (not nsfw.safe)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mirador
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Nick Jacob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-17 00:00:00.000000000 Z
+date: 2014-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty