bark 0.0.2

data/lib/bark/request/graph_of_life.rb

@@ -0,0 +1,76 @@
+class Bark::Request::GraphOfLife < Bark::Request
+
+    API_VERSION = 'v2'  
+    SEARCH_BASE = [Bark::Request::BASE_URL, API_VERSION, 'graph'].join("/")  
+
+    # Method: {parameters} 
+    METHODS = { 
+      gol_about: %i{},
+      gol_source_tree: %i{},
+      gol_node_info: %i{}, #  tree_id "is superflous and can be ignored"
+    }
+
+    # node_ids or ott_ids are required in some cases, so this
+    # will have to be cased 
+    REQUIRED_PARAMS = {
+    }
+
+    mrp = {}
+    
+    REQUIRED_PARAMS.each do |k,v|
+      v.each do |m|
+        mrp[m].push(k) if mrp[m] 
+        mrp[m] ||= [k]
+      end
+    end
+
+    METHODS_REQUIRED_PARAMS = mrp
+
+    def initialize(method: :tol_about, params: {})
+      assign_options(method: method, params: params)
+      build_uri if valid?
+    end
+
+    def assign_options(method: method, params: params)
+      @method = method
+      @params = params
+      @params ||= {}
+    end
+
+    def valid?
+      raise "Method #{@method} not recognized." if @method && !self.class::METHODS.keys.include?(@method)
+      !@method.nil? && params_are_supported? && has_required_params?
+    end
+
+    def has_required_params?
+      case @method
+      when :gol_of_life
+      end
+     return true
+    end
+
+    def json_payload
+      JSON.generate(@params)
+    end
+
+    private 
+
+    # TODO: this doesn't feel right (or could be generalized out to superclass)
+    def build_uri
+      @uri = URI( SEARCH_BASE + '/' + send("#{@method}_url") )
+    end
+
+    def gol_about_url
+     'about' 
+    end
+
+    def gol_source_tree_url
+     'source_tree'
+    end
+
+    def gol_node_info_url
+      'node_info' 
+    end 
+
+
+  end

data/lib/bark/request/studies.rb

@@ -0,0 +1,82 @@
+class Bark::Request::Studies < Bark::Request
+
+  API_VERSION = 'v2'  
+  FORMAT = 'json'
+  SEARCH_BASE = [Bark::Request::BASE_URL, API_VERSION].join("/") 
+
+  # Studies methods are slightly different because of the API differences
+  METHODS = { 
+    studies_find_studies: %i{property value exact verbose},
+    studies_find_trees: %i{property value exact verbose},
+    studies_properties: %i{}, 
+    get_study: %i{study_id},               # GET, not post
+    get_study_tree: %i{study_id tree_id},  # GET, not post
+  }
+
+  REQUIRED_PARAMS = {
+    study_id: %i{study get_study_tree},
+    tree_id:  %i{get_study_tree},
+    property: %i{studies_find_trees},
+    value:  %i{studies_find_trees}
+  }
+
+  mrp = {}
+
+  REQUIRED_PARAMS.each do |k,v|
+    v.each do |m|
+      mrp[m].push(k) if mrp[m] 
+      mrp[m] ||= [k]
+    end
+  end
+
+  METHODS_REQUIRED_PARAMS = mrp
+
+  # Only studies takes a method parameter
+  attr_accessor :method
+
+  def initialize(method: :study_list, params: {})
+    assign_options(method: method, params: params)
+    build_uri if valid?
+  end
+
+  def assign_options(method: method, params: params)
+    @method = method.to_sym
+    @params = params
+  end
+
+  def valid?
+    raise "Method #{@method} not recognized." if @method && !Bark::Request::Studies::METHODS.keys.include?(@method)
+    !@method.nil? && params_are_supported? && has_required_params?
+  end
+
+  def json_payload
+    JSON.generate(@params)
+  end
+
+  private 
+
+  # TODO: this doesn't feel right
+  def build_uri
+    @uri = URI( SEARCH_BASE +  send("#{@method}_url") )
+  end
+
+  def studies_find_studies_url
+    '/studies/find_studies' 
+  end
+
+  def studies_find_trees_url
+    '/studies/find_trees' 
+  end
+
+  def studies_properties_url
+    '/studies/properties' 
+  end
+
+  def get_study_tree_url
+    "/study/#{@params[:study_id]}/tree/#{@params[:tree_id]}"
+  end
+
+  def get_study_url
+    '/study/' + @params[:study_id].to_s
+  end 
+end

data/lib/bark/request/taxonomy.rb

@@ -0,0 +1,78 @@
+class Bark::Request::Taxonomy < Bark::Request
+
+    API_VERSION = 'v2'  
+    SEARCH_BASE = [Bark::Request::BASE_URL, API_VERSION, 'taxonomy'].join("/")  
+
+    # Method: {parameters} 
+    METHODS = { 
+      taxonomy_about: %i{},
+      taxonomy_lica: %i{},
+      taxonomy_subtree: %i{}, 
+      taxonomy_taxon: %i{}, 
+    }
+
+    REQUIRED_PARAMS = {
+    }
+
+    mrp = {}
+    
+    REQUIRED_PARAMS.each do |k,v|
+      v.each do |m|
+        mrp[m].push(k) if mrp[m] 
+        mrp[m] ||= [k]
+      end
+    end
+
+    METHODS_REQUIRED_PARAMS = mrp
+
+    def initialize(method: :tol_about, params: {})
+      assign_options(method: method, params: params)
+      build_uri if valid?
+    end
+
+    def assign_options(method: method, params: params)
+      @method = method
+      @params = params
+      @params ||= {}
+    end
+
+    def valid?
+      raise "Method #{@method} not recognized." if @method && !self.class::METHODS.keys.include?(@method)
+      !@method.nil? && params_are_supported? && has_required_params?
+    end
+
+    def has_required_params?
+      case @method
+      when :taxonomy_about
+      end 
+      return true
+    end
+
+    def json_payload
+      JSON.generate(@params)
+    end
+
+    private 
+
+    # TODO: this doesn't feel right (or could be generalized out to superclass)
+    def build_uri
+      @uri = URI( SEARCH_BASE + '/' + send("#{@method}_url") )
+    end
+
+    def taxonomy_about_url
+      'about' 
+    end
+
+    def taxonomy_lica_url
+      'lica'
+    end
+
+    def taxonomy_subtree_url 
+      'subtree' 
+    end 
+
+    def taxonomy_taxon_url 
+      'taxon'
+    end
+
+  end

data/lib/bark/request/tnrs.rb

@@ -0,0 +1,75 @@
+class Bark::Request::Tnrs < Bark::Request
+
+    API_VERSION = 'v2'  
+    SEARCH_BASE = [Bark::Request::BASE_URL, API_VERSION, 'tnrs'].join("/")  
+
+    # Method: {parameters} 
+    METHODS = { 
+      tnrs_match_names: %i{},
+      tnrs_contexts: %i{},
+      tnrs_infer_context: %i{}, 
+    }
+
+    # node_ids or ott_ids are required in some cases, so this
+    # will have to be cased 
+    REQUIRED_PARAMS = {
+    }
+
+    mrp = {}
+    
+    REQUIRED_PARAMS.each do |k,v|
+      v.each do |m|
+        mrp[m].push(k) if mrp[m] 
+        mrp[m] ||= [k]
+      end
+    end
+
+    METHODS_REQUIRED_PARAMS = mrp
+
+    def initialize(method: :tol_about, params: {})
+      assign_options(method: method, params: params)
+      build_uri if valid?
+    end
+
+    def assign_options(method: method, params: params)
+      @method = method
+      @params = params
+      @params ||= {}
+    end
+
+    def valid?
+      raise "Method #{@method} not recognized." if @method && !self.class::METHODS.keys.include?(@method)
+      !@method.nil? && params_are_supported? && has_required_params?
+    end
+
+    def has_required_params?
+     #case @method
+     #when :foo  
+     #end
+      return true
+    end
+
+    def json_payload
+      JSON.generate(@params)
+    end
+
+    private 
+
+    # TODO: this doesn't feel right (or could be generalized out to superclass)
+    def build_uri
+      @uri = URI( SEARCH_BASE + '/' + send("#{@method}_url") )
+    end
+
+    def tnrs_match_names_url 
+     'match_names' 
+    end
+
+    def tnrs_contexts_url
+     'contexts'
+    end
+
+    def tnrs_infer_context_url
+      'infer_context' 
+    end 
+
+  end

data/lib/bark/request/tree_of_life.rb

@@ -0,0 +1,91 @@
+class Bark::Request::TreeOfLife < Bark::Request
+
+    API_VERSION = 'v2'  
+    SEARCH_BASE = [Bark::Request::BASE_URL, API_VERSION, 'tree_of_life'].join("/")  
+
+    # Method: {parameters} 
+    METHODS = { 
+      tol_about: %i{},
+      tol_mrca: %i{node_ids ott_ids},
+      tol_subtree: %i{node_id ott_id}, #  tree_id "is superflous and can be ignored"
+      tol_induced_subtree: %i{node_ids ott_ids}, 
+    }
+
+    # node_ids or ott_ids are required in some cases, so this
+    # will have to be cased 
+    REQUIRED_PARAMS = {
+    }
+
+    mrp = {}
+    
+    REQUIRED_PARAMS.each do |k,v|
+      v.each do |m|
+        mrp[m].push(k) if mrp[m] 
+        mrp[m] ||= [k]
+      end
+    end
+
+    METHODS_REQUIRED_PARAMS = mrp
+
+    def initialize(method: :tol_about, params: {})
+      assign_options(method: method, params: params)
+      build_uri if valid?
+    end
+
+    def assign_options(method: method, params: params)
+      @method = method
+      @params = params
+      @params ||= {}
+    end
+
+    def valid?
+      raise "Method #{@method} not recognized." if @method && !self.class::METHODS.keys.include?(@method)
+      !@method.nil? && params_are_supported? && has_required_params?
+    end
+
+    def has_required_params?
+      case @method
+      when :tol_mrca, :tol_induced_subtree
+        return false if @params == {} 
+        # Both empty
+        return false if ((@params[:node_ids] == []) || @params[:node_ids].nil?) && ((@params[:ott_ids] == []) || @params[:ott_ids].nil?)
+      when :tol_subtree
+        # Both provided
+        return false if !@params[:node_id].nil? && !@params[:ott_id].nil?
+        # Neither provided
+        return false unless !@params[:node_id].nil? || !@params[:ott_id].nil? 
+      when :tol_about
+      else
+        raise "Curious, #{@method} is not a method."
+      end
+      return true
+    end
+
+    def json_payload
+      JSON.generate(@params)
+    end
+
+    private 
+
+    # TODO: this doesn't feel right (or could be generalized out to superclass)
+    def build_uri
+      @uri = URI( SEARCH_BASE + '/' + send("#{@method}_url") )
+    end
+
+    def tol_about_url
+     'about' 
+    end
+
+    def tol_mrca_url
+     'mrca'
+    end
+
+    def tol_subtree_url
+      'subtree' 
+    end 
+
+    def tol_induced_subtree_url
+      'induced_subtree'
+    end
+
+  end

data/lib/bark/response.rb

@@ -0,0 +1,51 @@
+class Bark 
+  class Response
+    
+    # All OT responses are in json format.  The json is stored here as a hash (dictionary).
+    attr_reader :json
+
+    def initialize(request: {}) 
+      raise 'No request passed' if request == {} || request.nil?
+      # warn Bark::Error, 'Warning request is not valid, making it anyway.' if !request.valid?
+
+      @json = {}
+
+      
+      if [:get_study, :get_study_tree ].include?( request.method  )
+        req = Net::HTTP::Get.new(request.uri)
+      else
+        req = Net::HTTP::Post.new(request.uri, initheader = {'Content-Type' =>'application/json'})
+      end 
+      
+      res = Net::HTTP.start(request.uri.hostname, request.uri.port) do |http|
+        req.body = request.json_payload
+        http.request(req)
+      end
+
+      parse_json(res.body)
+   end
+
+    # Parse the json, and store it in @json.
+    def parse_json(string)
+      begin
+        @json = JSON.parse(string) 
+      rescue JSON::ParserError => e
+        puts e.message
+        ap request
+      end
+    end
+
+    def request_succeeded?
+      !@json['exception'] && !@json['error']
+    end
+
+    def request_failure_message
+      @json['message']
+    end
+
+    def result
+      @json
+    end
+
+  end
+end