basuco 0.0.3

data/lib/basuco/search.rb

@@ -0,0 +1,100 @@
+module Basuco
+  class << self
+    attr_accessor :search
+  end
+  
+  # partially taken from chris eppstein's freebase api
+  # http://github.com/chriseppstein/freebase/tree
+  class Search
+    include Request
+    public
+    # @param host<String>          the API host
+    # @param username<String>      freebase username
+    # @param password<String>      user password
+    def initialize(options = {:host => 'http://www.freebase.com', :username => 'un', :password => 'pw'})
+      @host = options[:host]
+      @username = options[:username]
+      @password = options[:password]
+      Basuco.search = self
+
+      # TODO: check connection
+    end
+    
+    # Perform a mqlread and return the results
+    # Specify :cursor => true to batch the results of a query, sending multiple requests if necessary.
+    # TODO: should support multiple queries
+    #       you should be able to pass an array of queries
+    def mqlread(query, options = {})
+      cursor = options[:cursor]
+      if cursor
+        query_result = []
+        while cursor
+          response = get_query_response(query, cursor)
+          query_result += response['result']
+          cursor = response['cursor']
+        end
+      else
+        response = get_query_response(query, cursor)
+        cursor = response['cursor']
+        query_result = response['result']
+      end
+      query_result
+    end
+
+
+      # Executes an Mql Query against the Freebase API and returns the result as
+    # a <tt>Collection</tt> of <tt>Resources</tt>.
+    def all(options = {})
+      #assert_kind_of 'options', options, Hash
+      query = { :name => nil }.merge!(options).merge!(:id => nil)
+      result = mqlread([ query ], :cursor => !options[:limit])    
+      Basuco::Collection.new(result.map { |r| Basuco::Resource.new(r) })
+    end
+
+      
+    # Executes an Mql Query against the Freebase API and returns the result wrapped
+    # in a <tt>Resource</tt> Object.
+    #
+    # == Examples
+    #
+    #  Basuco.get('/en/the_police') => #<Resource id="/en/the_police" name="The Police">
+    # @api public
+    def get(id)
+      Basuco::Resource.get(id)
+    end
+
+    
+    def topic(id, options = {})
+      options.merge!({:id => id})
+
+      response = http_request topic_service_url+"/standard", options
+            --debugger
+      result = JSON.parse response
+      inner = result[id]
+      handle_read_error(inner)
+      inner['result']
+    end
+    
+    def search(query, options = {})
+      options.merge!({:query => query})
+      
+      response = http_request search_service_url, options
+      result = JSON.parse response
+      
+      handle_read_error(result)
+      
+      result['result']
+    end
+
+    
+    #yes or no
+    def status?
+      response = http_request status_service_url
+      result = JSON.parse response
+      return result["code"] == "/api/status/ok"
+    end
+
+
+
+  end # class Search
+end # module Basuco

data/lib/basuco/topic.rb

@@ -0,0 +1,192 @@
+module Basuco
+  class Topic
+    
+    attr_reader :data
+    
+    # initializes a topic using a json result
+    def initialize(data)
+     # assert_kind_of 'data', data, Hash
+      @data = data
+      @schema_loaded, @attributes_loaded = false, false
+    end
+    
+    # Retrieves a topic using the Topic API by Freebase
+    # returns a <tt>Topic</tt> Object.
+    #
+    # == Examples
+    #
+    #  Basuco::Topic.get('/en/the_police') => #<Topic id="/en/the_police" name="The Police">
+    # @api public
+    def self.get(id)
+      #assert_kind_of 'id', id, String
+      result = Basuco.search.topic(id)
+      raise TopicNotFound unless result
+      Basuco::Topic.new(result)
+    end
+    
+    # topic id
+    # @api public
+    def id
+      @data["id"] || ""
+    end
+    
+    # topic aliases
+    def aliases
+      @data["alias"]
+    end
+    
+    # topic freebase url
+    def url
+      @data["url"]
+    end
+    
+    # topic name
+    # @api public
+    def name
+      text
+    end
+    
+    # topic description
+    # @api public
+    def description
+      @data["description"]
+    end
+    
+    # topic text
+    # @api public
+    def text
+      @data["text"]
+    end
+    
+    # topic thumbnail
+    def thumbnail
+      @data["thumbnail"]
+    end
+    
+    # @api public
+    def to_s
+      name || id || ""
+    end
+
+    # @api public
+    def inspect
+      result = "#<Topic id=\"#{id}\" name=\"#{name || "nil"}\">"
+    end
+    
+    # topic webpages
+    # currently returned as an array of hashes containing the keys "text" and "url"
+    # that hashes may be wrapped into a Webpage class later
+    # @api public
+    def webpages
+      @data["webpage"]
+    end
+    
+    # returns all assigned types
+    # @api public
+    def types
+      load_schema! unless schema_loaded?
+      @types
+    end
+    
+    # returns individual type based on the requested type id
+    # @api public
+    def type(type)
+      types.each { |t| return t if t.id =~ /^#{Regexp.escape(type)}$/}
+      nil
+    end
+    
+    # returns all the properties from all assigned types
+    # @api public
+    def properties
+      @properties = Basuco::Collection.new
+      types.each do |type|
+        @properties.concat(type.properties)
+      end
+      @properties
+    end
+    
+    # returns all attributes for every type the topic is an instance of
+    # @api public
+    def attributes
+      load_attributes! unless attributes_loaded?
+      @attributes.values
+    end 
+    
+    # returns all available views based on the assigned types
+    # @api public
+    def views
+      @views ||= Basuco::Collection.new(types.map { |type| Basuco::View.new(self, type) })
+    end
+    
+    # returns individual view based on the requested type id
+    # @api public
+    def view(type)
+      views.each { |v| return v if v.type.id =~ /^#{Regexp.escape(type)}$/}
+      nil
+    end
+    
+    
+    # search for an attribute by name and return it
+    # @api public
+    def attribute(name)
+      attributes.each { |a| return a if a.property.id == name }
+      nil
+    end
+    
+    # returns true if type information is already loaded
+    # @api public
+    def schema_loaded?
+      @schema_loaded
+    end
+    
+    # returns true if attributes are already loaded
+    # @api public
+    def attributes_loaded?
+      @attributes_loaded
+    end
+    
+    private
+    
+    # loads the full set of attributes using reflection
+    # information is extracted from master, value and reverse attributes
+    # @api private
+    def load_attributes!
+      load_schema! unless schema_loaded?
+      
+      @attributes = {}
+      @data["properties"].each do |id, data|
+        # skip mediator properties for now
+        if !data["properties"]
+          values = []
+          data["values"].each do |value|
+            values << { "id" => value["id"], "name" => value["text"], "value" => value["text"] }
+          end
+          @attributes[id] = Basuco::Attribute.create(values, properties.select { |p| p.id == id }.first)
+        end
+      end
+      
+      @attributes_loaded = true
+    end
+    
+    # loads the topic's metainfo
+    # @api private
+    def load_schema!
+      result = {}
+      
+      @data["type"].each do |type|
+        result[type["id"]] = { "id" => type["id"], "name" => type["text"], "properties" => [] }
+      end
+      @data["properties"].each do |id, data|        
+        result[id.gsub(/\/\w*$/, "")]["properties"] << {
+          "expected_type" => data["expected_type"]["id"],
+          "id" => id,
+          "name" => data["text"],
+          "unique" => true 
+        }
+      end
+      @types = Basuco::Collection.new(result.values.map { |type| Basuco::Type.new(type) })
+      @schema_loaded = true
+    end
+    
+  end # class Topic
+end # module Basuco

data/lib/basuco/trans.rb

@@ -0,0 +1,36 @@
+module Basuco
+  class << self
+    attr_accessor :trans
+  end
+  
+  # partially taken from chris eppstein's freebase api
+  # http://github.com/chriseppstein/freebase/tree
+  class Trans
+    include Request
+
+    def initialize(options = {:host => 'http://www.freebase.com', :username => 'un', :password => 'pw'})
+      @host = options[:host]
+      @username = options[:username]
+      @password = options[:password]
+      Basuco.trans = self
+    end
+
+        #yes or no
+    def status?
+      response = http_request status_service_url
+      result = JSON.parse response
+      return result["blob"] == "OK"
+    end
+    
+    def raw_content(id, options = {})
+      response = http_request raw_service_url+id, options
+      response
+    end
+    
+    def blurb_content(id, options = {})
+      response = http_request blurb_service_url+id, options
+      response
+    end
+    
+  end
+end

data/lib/basuco/type.rb

@@ -0,0 +1,53 @@
+module Basuco
+  class Type
+    
+   # include Extlib::Assertions
+    
+    # initializes a resource using a json result
+    def initialize(data)
+     # assert_kind_of 'data', data, Hash
+      @data = data
+    end
+    
+    # access property info
+    # @api public
+    def properties
+      @properties ||= Basuco::Collection.new(@data["properties"].map { |property| Basuco::Property.new(property, self) })
+    end
+    
+    # type id
+    # @api public
+    def id
+      @data["id"]
+    end
+    
+    # type name
+    # @api public
+    def name
+      @data["name"]
+    end
+    
+    # @api public
+    def to_s
+      name || id || ""
+    end
+    
+    # @api public
+    def inspect
+      result = "#<Type id=\"#{id}\" name=\"#{name || "nil"}\">"
+    end
+    
+    # delegate to property_get
+    def method_missing sym
+      property_get(sym.to_s)
+    end
+    
+    private
+    # @api private
+    # search for a property by name and return it
+    def property_get(name)
+      properties.each { |p| return p if p.id =~ /\/#{name}$/ }
+      raise PropertyNotFound
+    end
+  end
+end

data/lib/basuco/util.rb

@@ -0,0 +1,17 @@
+module Basuco
+  module Util
+    # magic hash conversion
+    def convert_hash(source)
+      source.inject({}) do |result, item|
+        if result[item["link"]]
+          result[item["link"]] << { "id" => item["id"], "name" => item["name"], "value" => item["value"] }
+        else
+          result[item["link"]] = []
+          result[item["link"]] << { "id" => item["id"], "name" => item["name"], "value" => item["value"] }
+        end
+        result
+      end
+    end
+    module_function :convert_hash
+  end
+end

data/lib/basuco/version.rb

@@ -0,0 +1,3 @@
+module Basuco
+  VERSION = "0.0.3"
+end

data/lib/basuco/view.rb

@@ -0,0 +1,54 @@
+# provides an interface to view a subject (resource or topic) as a specific type
+# provides an interface for working with attributes, properties
+module Basuco
+  class View
+    
+    
+    # initializes a subject (resource or topic) by json result
+    def initialize(subject, type)
+    #  assert_kind_of 'type', type, Basuco::Type
+      @subject, @type = subject, type
+    end
+    
+    # @api public
+    def to_s
+      @type.to_s
+    end
+    
+    # return correspondent type
+    # @api public
+    def type
+      @type
+    end
+    
+    # @api public
+    def inspect
+      result = "#<View type=\"#{type.id || "nil"}\">"
+    end
+    
+    # returns attributes which are member of the view's type
+    # @api public
+    def attributes
+      @subject.attributes.select { |a| a.property.type == @type}
+    end
+    
+    # search for an attribute by name and return it
+    # @api public
+    def attribute(name)
+      attributes.each { |a| return a if a.property.id =~ /\/#{name}$/ }
+      nil
+    end
+    
+    # returns properties which are member of the view's type    
+    # @api public
+    def properties
+      @subject.properties.select { |p| p.type == @type}
+    end
+    
+    # delegate to attribute
+    def method_missing sym
+      attribute(sym.to_s)
+    end
+    
+  end
+end