calculated 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Richard Hooker
+
+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/ROADMAP.md

@@ -0,0 +1 @@
+Its coming

data/lib/calculated.rb

@@ -0,0 +1,22 @@
+# requires
+require "httparty"
+require "hashie"
+require "moneta"
+require "moneta/memory"
+
+
+require "calculated/generic_object_api_calls"
+require "calculated/object_template_api_calls"
+require "calculated/relatable_category_api_calls"
+require "calculated/answer_api_calls"
+require "calculated/session"
+require "calculated/service"
+require "calculated/logging"
+
+require "calculated/models/characteristic"
+require "calculated/models/formula_input"
+require "calculated/models/generic_object"
+require "calculated/models/object_template"
+require "calculated/models/relatable_category"
+require "calculated/models/source"
+require "calculated/models/answer"

data/lib/calculated/answer_api_calls.rb

@@ -0,0 +1,24 @@
+module Calculated
+  module AnswerApiCalls    
+  
+    # @param [String] id
+    # @param [Hash] params
+    # @return [Array<Calculated::Models::Answer>]
+    def answer_for_calculator(calculator_id, params = {})
+      api_call(:get, "/calculators/#{calculator_id}/answer", params) do |response|
+        Calculated::Models::Answer.new(response)
+      end
+    end
+    
+    
+    # @param [String] id
+    # @param [Hash] params
+    # @return [Array<Calculated::Models::Answer>]
+    def answer_for_computation(compuation_id, params = {})
+      api_call(:get, "/computations/#{compuation_id}/answer", params) do |response|
+        Calculated::Models::Answer.new(response)
+      end
+    end
+  
+  end
+end

data/lib/calculated/generic_object_api_calls.rb

@@ -0,0 +1,30 @@
+module Calculated
+  module GenericObjectApiCalls    
+  
+    # @param [Hash] params
+    # @return [Array<Calculated::Models::GeneriObject>]
+    def generic_objects(params = {})
+      api_call(:get, "/generic_objects", params) do |response|
+        response["generic_objects"].map{|generic_object| Calculated::Models::GenericObject.new(generic_object)}
+      end
+    end
+  
+    # @param [String] id
+    # @param [Hash] params
+    # @return [Calculated::Models::GeneriObject
+    def generic_object(id, params = {})
+      api_call(:get, "/generic_objects/#{id}", params) do |response|
+         Calculated::Models::GenericObject.new(response["generic_object"])
+      end
+    end
+  
+    # @param [String] id
+    # @param [Hash] params
+    # @return [Array<Calculated::Models::FormulaInput>]
+    def formula_inputs_for_generic_object(id, params = {})
+      api_call(:get, "/generic_objects/#{id}/formula_inputs", params) do |response|
+       response["formula_inputs"].map{|formula_input| Calculated::Models::FormulaInput.new(formula_input)}
+      end
+    end
+  end
+end

data/lib/calculated/logging.rb

@@ -0,0 +1,41 @@
+require 'benchmark'
+module Calculated
+  @@logger = nil
+  def self.logger=(logger)
+    @@logger = logger
+  end
+  def self.logger
+    @@logger
+  end
+
+  module Logging
+    def self.log_calculated_api(method, path, options)
+      message = method 
+      dump = format_da_dump(path, options)
+      if block_given?
+        result = nil
+        seconds = Benchmark.realtime { result = yield }
+        log_info(message, dump, seconds) 
+        result
+      else
+        log_info(message, dump) 
+        nil
+      end
+    rescue Exception => e
+      exception = "#{e.class.name}: #{e.message}: #{dump}"
+      log_info(message, exception)
+      raise
+    end
+    
+    def self.format_da_dump(path, params)
+      "Calculated: PATH: #{path} PARAMS: #{params.inspect}"
+    end
+    
+    def self.log_info(message, dump, seconds = 0)
+      return unless Calculated.logger
+      log_message = "#{message} (#{seconds}) #{dump}"
+      Calculated.logger.info(log_message)
+    end
+    
+  end  
+end

data/lib/calculated/models/answer.rb

@@ -0,0 +1,31 @@
+# Answers from the api
+#  calculations will be in the form of a hash with value and units keys
+#   answer.calculations["co2"]["value"] == 10
+#   answer.calculations["co2"]["units"] == "kg"
+module Calculated
+  module Models
+    class Answer  < Hashie::Dash
+      
+      # properties
+      property :calculations # [Hash]
+      property :object_references # [Hash]
+      property :used_global_computations # [Hash]
+      property :calculator_id # [String]
+      property :computation_id # [String]
+      property :answer_set_id # [String]
+      property :source # [Calculated::Models::Source]
+      property :errors # [Hash]
+                  
+      def source=(value)
+        unless value.nil?
+          self[:source] = Models::Source.new(value)
+        end
+      end
+      
+      def valid?
+        errors.nil?
+      end
+      
+    end
+  end
+end

data/lib/calculated/models/characteristic.rb

@@ -0,0 +1,18 @@
+module Calculated
+  module Models
+    class Characteristic < Hashie::Dash
+      
+      # properties
+      property :id # [String]
+      property :attribute # [String]
+      property :value # [String]
+      property :value_type # [String]
+      property :units # [String]
+      property :image_id # [String]
+      property :image_name # [String]
+      property :image_size # [String]
+      property :image_type # [String]
+          
+    end
+  end
+end

data/lib/calculated/models/formula_input.rb

@@ -0,0 +1,19 @@
+module Calculated
+  module Models
+    class FormulaInput < Hashie::Dash
+      
+      # properties
+      property :id # [String]
+      property :values # [Hash]
+      property :name # [String]
+      property :base_unit # [String]
+      property :active_at # [Time] yes time
+      property :main_source_id # [String]
+      property :group_name # [String]
+      property :input_units # [String]
+      property :label_input_units # [String]
+      property :model_state # [String]
+          
+    end
+  end
+end

data/lib/calculated/models/generic_object.rb

@@ -0,0 +1,34 @@
+module Calculated
+  module Models
+    class GenericObject < Hashie::Dash
+      
+      # properties
+      property :id # [String]
+      property :template_name # [String]
+      property :identifier # [String]
+      property :characteristics # [Array<Calculated::Models::Characteristic>]
+      property :formula_inputs # [Array<Calculated::Models::FormulaInput>]
+      
+      # dont ask why I need to check for nil? here just dont!
+      def characteristics=(value)
+        unless value.nil?
+          self[:characteristics] = value.map{|characteristic| Calculated::Models::Characteristic.new(characteristic)}
+        end
+      end
+      
+      # setting the formula inputs to a defined model
+      def formula_inputs=(value)
+        unless value.nil?
+          self[:formula_inputs] = value.map{|formula| Calculated::Models::FormulaInput.new(formula)}
+        end
+      end
+      
+      def used_formula_inputs=(value)
+        unless value.nil?
+          self[:used_formula_inputs] = value.map{|formula| Calculated::Models::FormulaInput.new(formula)}
+        end
+      end
+    
+    end
+  end
+end

data/lib/calculated/models/object_template.rb

@@ -0,0 +1,48 @@
+module Calculated
+  module Models
+    class ObjectTemplate < Hashie::Dash
+        
+      # properties
+      property :id # [String]
+      property :name # [String]
+      property :generic_objects # [Array<Calculated::Models::GenericObject>]
+      
+      # characteristics from an object template will not have a value property set as it is a template
+      property :characteristics # [Hash] not the same as generi_objects characteristics
+      
+      # formula_inputs from an object template will not have a value property set as it is a template
+      property :formula_inputs # [Hash] not the same as generi_objects formula_inputs
+      
+      property :relatable_categories # [Array<Calculated::Models::RelatableCategory>]
+      
+      # dont ask why I need to check for nil? here just dont!
+       def generic_objects=(value)
+         unless value.nil?
+           self[:generic_objects] = value.map{|generic_object| Calculated::Models::GenericObject.new(generic_object)}
+         end
+       end
+       
+       # dont ask why I need to check for nil? here just dont!
+       def characteristics=(value)
+         unless value.nil?
+           self[:characteristics] = value.map{|characteristic| Calculated::Models::Characteristic.new(characteristic)}
+         end
+       end
+
+       # setting the formula inputs to a defined model
+       def formula_inputs=(value)
+         unless value.nil?
+           self[:formula_inputs] = value.map{|formula| Calculated::Models::FormulaInput.new(formula)}
+         end
+       end
+       
+       # setting the formula inputs to a defined model
+       def relatable_categories=(value)
+         unless value.nil?
+           self[:relatable_categories] = value.map{|relatable_category| Calculated::Models::RelatableCategory.new(relatable_category)}
+         end
+       end
+
+    end
+  end
+end

data/lib/calculated/models/relatable_category.rb

@@ -0,0 +1,23 @@
+module Calculated
+  module Models
+    class RelatableCategory < Hashie::Dash
+              
+      # properties
+      property :id # [String]
+      property :name # [String]
+      property :related_attribute # [String] 
+      property :related_object_name # [String]      
+      # @example 
+      #  "emission_source" => {
+      #   {
+      #       "4c349f6068fe5434960178c2" => "flaring and venting",
+      #       "4c349f6068fe54349601791f" => "fugitives",
+      #   }    
+      # }
+      property :related_categories # [Hash{name => <Hash{:id => identifier}}]
+      
+      
+  
+    end
+  end
+end

data/lib/calculated/models/source.rb

@@ -0,0 +1,14 @@
+module Calculated
+  module Models
+    class Source  < Hashie::Dash
+      
+      # properties
+      property :id # [String]
+      property :description # [String]
+      property :main_source_ids # [Array<String>]
+      property :external_url # [String]
+      property :wave_id # [String]
+                  
+    end
+  end
+end

data/lib/calculated/object_template_api_calls.rb

@@ -0,0 +1,61 @@
+module Calculated
+  module ObjectTemplateApiCalls    
+  
+    # @param [Hash] params
+    # @return [Array<Calculated::Models::ObjectTemplate>]
+    def object_templates(params = {})
+      api_call(:get, "/object_templates", params) do |response|
+        response["object_templates"].map{|object_template| Calculated::Models::ObjectTemplate.new(object_template)}
+      end
+    end
+    
+    
+    # this request will have loaded generic objects for the ready basically
+    # @param [String] name
+    # @param [Hash] params
+    # @return [Calculated::Models::ObjectTemplate]
+    def generic_objects_for_object_template(name, params = {})
+      api_call(:get, "/object_templates/#{name}/generic_objects", params) do |response|
+         Calculated::Models::ObjectTemplate.new(response["object_template"])
+      end
+    end
+    
+    # this request will have loaded relatable categories for the object template
+    # @param [String] related_attribute
+    # @param [String] name
+    # @param [Hash] params
+    # @return [Calculated::Models::ObjectTemplate]
+    def relatable_categories_for_object_template(name, related_attribute, params = {})
+      api_call(:get, "/object_templates/#{name}/relatable_categories", params.merge!(:related_attribute => related_attribute)) do |response|
+         Calculated::Models::ObjectTemplate.new(response["object_template"])
+      end
+    end
+    
+    #   This will filter the results of the generic objects from a simple text search
+    #   note this is not an expancive text search so limit to 1 word searches for best
+    #   results
+    #
+    # @example
+    #   generic_objects_for_object_template_with_filter('airport', 'london')
+    #
+    #   There is also the usuage of relatable_category_values with the params
+    #   this will allow further filtering on the search its an AND Filter not an OR filter
+    #
+    # @example
+    #   searching for ford diesel cars for example
+    #
+    #   generic_objects_for_object_template_with_filter('car', 'diesel', :relatable_category_values => ["ford"])
+    #
+    # this request will have loaded relatable categories for the object template
+    # @param [String] name
+    # @param [String] filter
+    # @param [Hash] params
+    # @return [Calculated::Models::GeneriObject]
+    def generic_objects_for_object_template_with_filter(name, filter, params = {})
+      api_call(:get, "/object_templates/#{name}/generic_objects/filter", params.merge!(:filter => filter)) do |response|
+         Calculated::Models::ObjectTemplate.new(response["object_template"])
+      end
+    end
+    
+ end
+end

data/lib/calculated/relatable_category_api_calls.rb

@@ -0,0 +1,38 @@
+module Calculated
+  module RelatableCategoryApiCalls    
+  
+    # this call just beings back a native array with hash of ids and identifiers
+    # @example 
+    #   
+    #   "4bf42d8b46a95925b5001a0c" => "Particle Board"
+    #
+    # @param [String] template_name
+    # @param [Array<String>] relatable_category_ids
+    # @param [Hash] params
+    # @return [Hash]
+    def related_objects_from_relatable_categories(template_name, relatable_category_ids, params = {})
+      relatable_category_ids = relatable_category_ids.is_a?(String) ? [relatable_category_ids] : relatable_category_ids
+      api_call(:get, "/relatable_categories/related_objects", params.merge!(:template_name => template_name, :relatable_category_ids => relatable_category_ids)) do |response|
+        response["related_objects"]
+      end
+    end
+    
+    
+    
+    ## this call just beings back a native array with hash of ids and identifiers
+    # @example 
+    #   
+    #   "4bf42d8a46a95925b5001999" => "timber"
+    #
+    # @param [String] id
+    # @param [String] related_attribute
+    # @param [Hash] params
+    # @return [Hash]
+    def related_categories_from_relatable_category(id, related_attribute, params = {})
+      api_call(:get, "/relatable_categories/#{id}/related_categories", params.merge!(:related_attribute => related_attribute)) do |response|
+        response["related_categories"]
+      end
+    end
+     
+ end
+end

data/lib/calculated/service.rb

@@ -0,0 +1,51 @@
+module Calculated
+  class Service
+    include HTTParty
+    format :json
+    headers 'Accept' => 'application/json'
+    
+    # set the httparty defaults [this obviously makes 1 service] limitation me feels
+    def initialize(server, api_version, api_key)
+      self.class.base_uri "http://#{server}/api/#{api_version}"
+      self.class.default_params :api_key => api_key
+    end
+    
+    def get(path, params = {})
+      perform_request(:get, path, params)
+    end
+    
+    def post(path, params = {})
+      perform_request(:post, path, params)
+    end
+    
+    private
+    def perform_request(type, path, params)
+      response = self.class.send(type, path, :query => params)
+      check_response(response)
+      response
+    rescue Errno::ECONNREFUSED, SocketError
+      raise Calculated::Session::ServerNotFound, "Carbon Calculated Server could not be found"
+    end
+    
+    # checking the status code of the response; if we are not authenticated
+    # then authenticate the session
+    # @raise [Calculated::PermissionDenied] if the status code is 403
+    # @raise [Calculated::SessionExpired] if a we get a 401
+    # @raise [Calculated::MissingParameter] if we get something strange
+    def check_response(response)
+      case response.code
+        when 200, 201
+          true
+        when 401
+          raise Calculated::Session::PermissionDenied.new("Your Request could not be authenticated is your api key valid?")
+        when 404
+          raise Calculated::Session::NotFound.new("Resource was not found")
+        when 412
+          raise Calculated::Session::MissingParameter.new("Missing Parameter: #{response.body}")
+        else
+          raise Calculated::Session::UnknownError.new("super strange type unknown error: #{response.code} :body #{response.body}")
+      end
+    end
+  
+  end
+end

data/lib/calculated/session.rb

@@ -0,0 +1,106 @@
+require 'active_support/core_ext/object/to_query'
+module Calculated
+  class Session
+    
+    class CalculatedError < StandardError ;end
+    class Expired < CalculatedError; end
+    class UnAuthorized < CalculatedError; end
+    class NotAuthenticated < CalculatedError; end
+    class PermissionDenied < CalculatedError; end
+    class NotFound < CalculatedError; end
+    class ServerNotFound < CalculatedError; end
+    class MissingParameter < CalculatedError; end
+    class UnknownError < CalculatedError; end
+    
+    # api calls that can be made on the session
+    include Calculated::GenericObjectApiCalls
+    include Calculated::ObjectTemplateApiCalls
+    include Calculated::RelatableCategoryApiCalls
+    include Calculated::AnswerApiCalls
+    
+    # accessors
+    attr_accessor :cache, :caching, :logging, :server, :expires_in, :api_version
+    
+    # creating a session one must supply the api_key as this is always required basically
+    # @param [Hash] options
+    # @return [Calculated::Session]
+    def self.create(options = {})
+      api_key = options.delete(:api_key)
+      raise ArgumentError.new("You need an API Key to save the planet") unless api_key
+      new(api_key, options)
+    end
+    
+    # @param [String] api_key
+    # @param [Hash] options
+    # default options
+    #   caching => true
+    #   expires_in => 60*60*24
+    #   cache => Moneta::Memory.new
+    #   server => "api.carboncalculated.com"
+    #   api_version => "v1"
+    #   logging => true
+    def initialize(api_key, options)
+      @api_key = api_key
+      if @caching = options[:caching].nil? ? true : options.delete(:caching)
+        @expires_in = options.delete(:expires_in) || 60*60*24
+        @cache = options.delete(:cache) || Moneta::Memory.new 
+      end
+      @server = options.delete(:server) || "api.carboncalculated.com"
+      @api_version = options.delete(:api_version) || "v1"
+      @logging = options[:logging].nil? ? true : options.delete(:caching)
+    end
+    
+    
+    # api calls
+    def api_call_without_logging(method, path, params = {}, &proc)
+      result = service.send(method, path, params)
+      result = yield result if block_given?
+      store_call(result, path, params || {}) if caching?
+      result
+    end
+    
+    # if we caching and we have the same cache lets try and get the 
+    # cache; otherwise we will make the request logging if need be
+    def api_call(method, path, params ={}, &proc)
+      if cache = caching? && (@cache[cache_key(path, params)])
+        return cache
+      else
+        if @logging
+          Calculated::Logging.log_calculated_api(method, path, params) do
+            api_call_without_logging(method, path, params, &proc)
+          end
+        else
+          api_call_without_logging(method, path, params, &proc)
+        end
+      end
+    end
+    
+    def service 
+      @service ||= Calculated::Service.new(@server, @api_version, @api_key)
+    end
+    
+    def caching?
+      @caching
+    end
+      
+    protected
+    # @param [String] path
+    # @param [Hash] params
+    # @return [String] the cache key from the path and the params
+    def cache_key(path, params = {})
+      parts = []
+      parts << path
+      parts << params.to_query
+      parts.join("/")
+    end
+    
+    # @param [Object] result
+    # @param [String] path
+    # @param [Hash] params
+    def store_call(result, path, params)
+      key = cache_key(path, params ||{})
+      @cache.store(key, result, :expires_in => @expires_in)
+    end
+            
+  end
+end

data/lib/calculated/version.rb

@@ -0,0 +1,3 @@
+module Calculated
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: calculated
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Richard Hooker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta3
+        version: 3.0.0.beta3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: moneta
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 22
+        version: 0.3.22
+  type: :runtime
+  version_requirements: *id005
+description: makes using a simple api even more simple;
+email: 
+- richard.hooker@carboncalculated.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/calculated/answer_api_calls.rb
+- lib/calculated/generic_object_api_calls.rb
+- lib/calculated/logging.rb
+- lib/calculated/models/answer.rb
+- lib/calculated/models/characteristic.rb
+- lib/calculated/models/formula_input.rb
+- lib/calculated/models/generic_object.rb
+- lib/calculated/models/object_template.rb
+- lib/calculated/models/relatable_category.rb
+- lib/calculated/models/source.rb
+- lib/calculated/object_template_api_calls.rb
+- lib/calculated/relatable_category_api_calls.rb
+- lib/calculated/service.rb
+- lib/calculated/session.rb
+- lib/calculated/version.rb
+- lib/calculated.rb
+- LICENSE
+- CHANGELOG.md
+- ROADMAP.md
+has_rdoc: true
+homepage: http://github.com/hookercookerman/calculated
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: calculated
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A gem to use the carbon calculated api
+test_files: []
+