agraph 0.1.0.beta1

data/lib/allegro_graph/proxy/query.rb

@@ -0,0 +1,37 @@
+
+module AllegroGraph
+
+  module Proxy
+
+    class Query
+
+      LANGUAGES = [ :sparql, :prolog ].freeze unless defined?(LANGUAGES)
+
+      attr_reader :server
+      attr_reader :resource
+      attr_reader :language
+
+      def initialize(resource)
+        @resource = resource
+        @language = :sparql
+      end
+
+      def path
+        @resource.path
+      end
+
+      def language=(value)
+        raise NotImplementedError, "query langauge [#{value}] is not implemented" unless LANGUAGES.include?(value.to_sym)
+        @language = value.to_sym
+      end
+
+      def perform(query)
+        parameters = { :query => query, :queryLn => @language.to_s }
+        @resource.request :get, self.path, :parameters => parameters, :expected_status_code => 200
+      end
+
+    end
+
+  end
+
+end

data/lib/allegro_graph/proxy/statements.rb

@@ -0,0 +1,59 @@
+
+module AllegroGraph
+
+  module Proxy
+
+    class Statements
+
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def path
+        "#{@resource.path}/statements"
+      end
+
+      def create(subject, predicate, object, context = nil)
+        statement = [ subject, predicate, object ]
+        statement << context if context
+        @resource.request :post, self.path, :body => [ statement ], :expected_status_code => 204
+        true
+      end
+
+      def find(options = { })
+        parameters = { }
+
+        { :subject => :subj, :predicate => :pred, :object => :obj, :context => :context }.each do |option_key, parameter_key|
+          value = options[option_key]
+          parameters.merge! value.is_a?(Array) ?
+                              { :"#{parameter_key}" => value[0], :"#{parameter_key}End" => value[1] } :
+                              { parameter_key => value } if value
+        end
+
+        [ :offset, :limit, :infer ].each do |key|
+          parameters.merge! key => options[key] if options.has_key?(key)
+        end
+
+        parameters = nil if parameters.empty?
+
+        @resource.request :get, self.path, :parameters => parameters, :expected_status_code => 200
+      end
+
+      def delete(options = { })
+        parameters = { }
+
+        { :subject => :subj, :predicate => :pred, :object => :obj, :context => :context }.each do |option_key, parameter_key|
+          value = options[option_key]
+          parameters.merge! parameter_key => value if value
+        end
+
+        @resource.request :delete, self.path, :parameters => parameters, :expected_status_code => 200
+      end
+
+    end
+
+  end
+
+end

data/lib/allegro_graph/repository.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), "server")
+require File.join(File.dirname(__FILE__), "session")
+require File.join(File.dirname(__FILE__), "proxy", "statements")
+require File.join(File.dirname(__FILE__), "proxy", "query")
+require File.join(File.dirname(__FILE__), "proxy", "geo")
+require File.join(File.dirname(__FILE__), "proxy", "mapping")
+
+module AllegroGraph
+
+  class Repository
+
+    attr_reader   :server
+    attr_reader   :catalog
+    attr_accessor :name
+
+    attr_reader   :statements
+    attr_reader   :query
+    attr_reader   :geo
+    attr_reader   :mapping
+
+    def initialize(server_or_catalog, name, options = { })
+      @catalog    = server_or_catalog.is_a?(AllegroGraph::Server) ? server_or_catalog.root_catalog : server_or_catalog
+      @server     = @catalog.server
+      @name       = name
+      @statements = Proxy::Statements.new self
+      @query      = Proxy::Query.new self
+      @geo        = Proxy::Geo.new self
+      @mapping    = Proxy::Mapping.new self
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && self.catalog == other.catalog && self.name == other.name
+    end
+
+    def path
+      "#{@catalog.path}/repositories/#{@name}"
+    end
+
+    def request(http_method, path, options = { })
+      @server.request http_method, path, options
+    end
+
+    def exists?
+      @catalog.repositories.include? self
+    end
+
+    def create!
+      @server.request :put, self.path, :expected_status_code => 204
+      true
+    rescue ExtendedTransport::UnexpectedStatusCodeError => error
+      return false if error.status_code == 400
+      raise error
+    end
+
+    def create_if_missing!
+      create! unless exists?
+    end
+
+    def delete!
+      @server.request :delete, self.path, :expected_status_code => 200
+      true
+    rescue ExtendedTransport::UnexpectedStatusCodeError => error
+      return false if error.status_code == 400
+      raise error
+    end
+
+    def delete_if_exists!
+      delete! if exists?
+    end
+
+    def size
+      response = @server.request :get, self.path + "/size", :type => :text, :expected_status_code => 200
+      response.to_i
+    end
+
+    def transaction(&block)
+      session = Session.create self
+      begin
+        session.instance_eval &block
+      rescue Object => error
+        session.rollback
+        raise error
+      end
+      session.commit
+    end
+
+  end
+
+end

data/lib/allegro_graph/server.rb

@@ -0,0 +1,68 @@
+require File.join(File.dirname(__FILE__), "transport")
+require File.join(File.dirname(__FILE__), "catalog")
+require File.join(File.dirname(__FILE__), "federation")
+
+module AllegroGraph
+
+  # The Server class provides methods to retrieve informations about a AllegroGraph server.
+  class Server
+
+    attr_reader :host
+    attr_reader :port
+    attr_reader :username
+    attr_reader :password
+    attr_reader :root_catalog
+
+    def initialize(options = { })
+      @host     = options[:host] || "localhost"
+      @port     = options[:port] || "10035"
+      @username = options[:username]
+      @password = options[:password]
+
+      @root_catalog = Catalog.new self, "root", :root => true
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @host == other.host && @port == other.port
+    end
+
+    def request(http_method, path, options = { })
+      ExtendedTransport.request http_method, self.url + path, credentials.merge(options)
+    end
+
+    def version
+      {
+        :version  => self.request(:get, "/version",          :expected_status_code => 200),
+        :date     => self.request(:get, "/version/date",     :expected_status_code => 200),
+        :revision => self.request(:get, "/version/revision", :expected_status_code => 200)
+      }
+    end
+
+    def catalogs
+      result = [ @root_catalog ]
+      catalogs = self.request :get, "/catalogs", :expected_status_code => 200
+      catalogs.each do |catalog|
+        id = catalog["id"]
+        result << Catalog.new(self, id.sub(/^\//, "")) unless id == "/"
+      end
+      result
+    end
+
+    def federations
+      federations = self.request :get, "/federated", :expected_status_code => 200
+      federations.map { |federation| Federation.new self, federation["id"] }
+    end
+
+    def url
+      "http://#{@host}:#{@port}"
+    end
+
+    private
+
+    def credentials
+      { :auth_type => :basic, :username => @username, :password => @password }
+    end
+
+  end
+
+end

data/lib/allegro_graph/session.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "transport")
+require File.join(File.dirname(__FILE__), "proxy", "statements")
+require File.join(File.dirname(__FILE__), "proxy", "query")
+require File.join(File.dirname(__FILE__), "proxy", "geo")
+require File.join(File.dirname(__FILE__), "proxy", "mapping")
+
+module AllegroGraph
+
+  class Session
+
+    attr_reader :url
+    attr_reader :username
+    attr_reader :password
+
+    attr_reader :statements
+    attr_reader :query
+    attr_reader :geo
+    attr_reader :mapping
+
+    def initialize(options = { })
+      @url      = options[:url]
+      @username = options[:username]
+      @password = options[:password]
+
+      @statements = Proxy::Statements.new self
+      @query      = Proxy::Query.new self
+      @geo        = Proxy::Geo.new self
+      @mapping    = Proxy::Mapping.new self
+    end
+
+    def path
+      ""
+    end
+
+    def request(http_method, path, options = { })
+      ExtendedTransport.request http_method, self.url + path, credentials.merge(options)
+    end
+
+    def commit
+      self.request :post, "/commit", :expected_status_code => 204
+      true
+    end
+
+    def rollback
+      self.request :post, "/rollback", :expected_status_code => 204
+      true
+    end
+
+    def self.create(repository)
+      url = repository.request :post, repository.path + "/session", :expected_status_code => 200
+      url.sub! /^"/, ""
+      url.sub! /"$/, ""
+      new :url => url, :username => repository.server.username, :password => repository.server.password
+    end
+
+    private
+
+    def credentials
+      { :auth_type => :basic, :username => @username, :password => @password }
+    end
+    
+  end
+
+end

data/lib/allegro_graph/transport.rb

@@ -0,0 +1,169 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'base64'
+require 'json'
+
+module AllegroGraph
+
+  # Common transport layer for http transfers.
+  class Transport
+
+    attr_reader :http_method
+    attr_reader :url
+    attr_reader :options
+    attr_reader :headers
+    attr_reader :parameters
+    attr_reader :body
+    attr_reader :response
+
+    def initialize(http_method, url, options = { })
+      @http_method  = http_method
+      @uri          = URI.parse url
+      @headers      = options[:headers]     || { }
+      @parameters   = options[:parameters]  || { }
+      @body         = options[:body]
+    end
+
+    def perform
+      initialize_request_class
+      initialize_request_path
+      initialize_request
+      initialize_request_body
+      perform_request
+    end
+
+    private
+
+    def initialize_request_class
+      request_class_name = @http_method.capitalize
+      raise NotImplementedError, "the request method #{http_method} is not implemented" unless Net::HTTP.const_defined?(request_class_name)
+      @request_class = Net::HTTP.const_get request_class_name
+    end
+
+    def initialize_request_path
+      serialize_parameters
+      @request_path = @uri.path + @serialized_parameters
+    end
+
+    def serialize_parameters
+      quote_parameters
+      @serialized_parameters = if @parameters.nil? || @parameters.empty?
+        ""
+      else
+        "?" + @quoted_parameters.collect do |key, value|
+          value.is_a?(Array) ?
+            value.map{ |element| "#{key}=#{element}" }.join("&") :
+            "#{key}=#{value}"
+        end.join("&")
+      end
+    end
+
+    def quote_parameters
+      @quoted_parameters = { }
+      @parameters.each do |key, value|
+        if value.is_a?(Array)
+          @quoted_parameters[ CGI.escape("#{key}") ] = value.map{ |element| CGI.escape element }
+        else
+          @quoted_parameters[ CGI.escape("#{key}") ] = CGI.escape value
+        end
+      end
+    end
+    
+    def initialize_request
+      @request = @request_class.new @request_path, @headers
+    end
+    
+    def initialize_request_body
+      return unless [ :post, :put ].include?(@http_method.to_sym)
+      @request.body = @body ? @body : @serialized_parameters.sub(/^\?/, "")
+    end
+
+    def perform_request
+      @response = Net::HTTP.start(@uri.host, @uri.port) do |connection|
+        connection.request @request
+      end
+    end
+
+    def self.request(http_method, url, options = { })
+      transport = new http_method, url, options
+      transport.perform
+      transport.response
+    end
+
+  end
+
+  class ExtendedTransport < Transport
+
+    # The UnexpectedStatusCodeError is raised if the :expected_status_code option is given to
+    # the :request method and the responded status code is different from the expected one.
+    class UnexpectedStatusCodeError < StandardError
+
+      attr_reader :status_code
+      attr_reader :message
+
+      def initialize(status_code, message)
+        @status_code, @message = status_code, message
+      end
+
+      def to_s
+        "#{super} received status code #{self.status_code}" + (@message ? " [#{@message}]" : "")
+      end
+
+    end
+
+    attr_reader :expected_status_code
+    attr_reader :auth_type
+    attr_reader :username
+    attr_reader :password
+    
+    def initialize(http_method, url, options = { })
+      super http_method, url, options
+      @expected_status_code = options[:expected_status_code]
+      @auth_type            = options[:auth_type]
+      @username             = options[:username]
+      @password             = options[:password]
+    end
+
+    def perform
+      initialize_headers
+      super
+      check_status_code
+      parse_response
+    end
+
+    private
+
+    def initialize_headers
+      if @auth_type == :basic
+        @headers["Authorization"] = "Basic " + Base64.encode64("#{@username}:#{@password}")
+      elsif !@auth_type.nil?
+        raise NotImplementedError, "the given auth_type [#{@auth_type}] is not implemented"
+      end
+      @headers["Accept"] = "application/json"
+    end
+
+    def initialize_request_body
+      super
+      if @body
+        @request.body = @body.to_json
+        @request["Content-Type"] = "application/json"
+      end
+    end
+
+    def check_status_code
+      return unless @expected_status_code
+      response_code = @response.code
+      response_body = @response.body
+      raise UnexpectedStatusCodeError.new(response_code.to_i, response_body) if @expected_status_code.to_s != response_code
+    end
+
+    def parse_response
+      @response = @response.body.nil? ? nil : JSON.parse(@response.body)
+    rescue JSON::ParserError
+      @response = @response.body.to_s
+    end
+
+  end
+
+end