foundationapi 0.9.9

data/lib/foundation_api/model/cached.rb

@@ -0,0 +1,13 @@
+module FoundationApi
+  module Model
+    module Cached
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def cached_find(id)
+          Rails.cache.fetch([self.name, id]) { find(id) }
+        end
+      end
+    end
+  end
+end

data/lib/foundation_api/model/mapping.rb

@@ -0,0 +1,24 @@
+require 'active_support/hash_with_indifferent_access.rb'
+
+module FoundationApi
+  module Model
+    module Mapping
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        def map_from_params(str)
+          HashWithIndifferentAccess[str.split('%%')[1..-1].collect do |p|
+            m = p.match /^([A-Za-z_]+)_\s(.*)$/
+            [m[1], m[2].strip]
+          end]
+        end        
+      end
+      
+      # TODO: change when on rails 4
+      # delegate :map_attribute, :reverse_map_attribute, to: :class
+      delegate :map_from_params, to: 'self.class'
+      
+      
+    end
+  end
+end

data/lib/foundation_api/request.rb

@@ -0,0 +1,29 @@
+module FoundationApi
+  module Request
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      delegate :request, :key_value_array, to: :'FoundationApi::JsonRPC::Client'
+      
+      def generate_event(type, params = {})
+        FoundationApi::Event::Client.request :generate_event, {:type => type, :fields => params}
+      end
+
+      def quote(arg)
+        case arg
+        when String, Symbol, Date
+          "'#{arg}'"
+        when Array
+          arg.collect { |e| quote(e)  }.join(', ')
+        else
+          arg.to_s
+        end
+      end
+    end
+    # TODO: change when on rails 4
+    # delegate :request, :key_value_array, to: :class
+    # delegate :generate_event, to: :class
+    delegate :request, :key_value_array, to: 'self.class'
+    delegate :generate_event, to: 'self.class'
+  end
+end

data/lib/foundation_api/service.rb

@@ -0,0 +1,56 @@
+module FoundationApi
+  class Service
+    include Request
+    include Model::AttributeMethods
+
+    class_attribute :service_name
+    class_attribute :default_scope
+    self.default_scope = {}
+
+    class << self
+      def where(options)
+        if options.is_a? Hash
+          options = {:conditions => options }
+        end
+        res = request_data(translate_options(options))
+        res && instantiate_objects(res)
+      end
+
+      def all
+        res = request_data(default_scope)
+        res && instantiate_objects(res)
+      end
+
+    private
+      def request_data(options = {})
+        res = request service_name, options
+      end
+
+      def instantiate_objects(data)
+        data.collect { |attributes| new(attributes)  }
+      end
+
+      def translate_options(*args)
+        options = args.extract_options!
+        if filter = options.delete(:conditions)
+          filter = case filter
+          when Hash
+            Hash[filter.collect { |attr, value| [map_attribute(attr), value] }]
+          when String
+            [args.first.split(' ').collect { |word| map_attribute(word) }.join(' ')]
+          else
+            raise "Dirty filter. Cannot translate"
+          end
+        else
+          filter = [args.first.split(' ').collect { |word| map_attribute(word) }.join(' ')]
+        end
+        default_scope.merge(filter)
+      end
+
+    end
+
+    def initialize(attributes = {})
+      @attributes = HashWithIndifferentAccess.new attributes
+    end
+  end
+end

data/lib/foundation_api/shoulda_matcher.rb

@@ -0,0 +1,15 @@
+module FoundationApi
+  module ShouldaMatcher
+    autoload :AttributeAliasMatcher, 'foundation_api/shoulda_matcher/attribute_alias_matcher'
+    autoload :PersistenceMethodMatcher, 'foundation_api/shoulda_matcher/persistence_method_matcher'
+
+    def have_attribute_alias(alias_name)
+      FoundationApi::ShouldaMatcher::AttributeAliasMatcher.new(alias_name)
+    end
+
+    def have_persistence_method(method)
+      FoundationApi::ShouldaMatcher::PersistenceMethodMatcher.new(method)
+    end
+  end
+end
+

data/lib/foundation_api/shoulda_matcher/attribute_alias_matcher.rb

@@ -0,0 +1,32 @@
+module FoundationApi
+  module ShouldaMatcher
+    class AttributeAliasMatcher
+      def initialize(alias_name)
+        @expected_alias_name = alias_name.to_s
+      end
+
+      def matches?(subject)
+        @klass = subject.class
+        @klass.attribute_aliases.has_key?(@expected_alias_name) && 
+          (@source_attribute ? @klass.attribute_aliases[@expected_alias_name] == @source_attribute : true)
+      end
+
+      def failure_message
+        "Expected attribute alias #{@expected_alias_name} for #{@source_attribute || 'unspecified source attribute'}"
+      end
+
+      def negative_failure_message
+        "Didn't expect attribute alias #{@expected_alias_name} but got one anyway"
+      end
+
+      def description
+        "have attribute alias #{@expected_alias_name}"
+      end
+
+      def for(source_attribute)
+        @source_attribute = source_attribute.to_s
+        self
+      end
+    end
+  end
+end

data/lib/foundation_api/shoulda_matcher/persistence_method_matcher.rb

@@ -0,0 +1,91 @@
+module FoundationApi
+  module ShouldaMatcher
+    class PersistenceMethodMatcher
+      def initialize(method)
+        @expected_method = method
+        @options = []
+      end
+      
+      def matches?(subject)
+        @klass = subject.class
+        method_supported? && interface_matches? && acceptable_options? && !option_failure?
+      end
+    
+      def failure_message
+        message = []
+        message << "You specified an illegal caller #{@expected_method.inspect}" unless method_supported?
+        message << "One of the options you specified #{@options.inspect} is not backed by the method #{@expected_method.inspect}" unless acceptable_options?
+        message << option_failure? if option_failure?
+        message.join(" and\n")
+      end
+    
+      def negative_failure_message
+        "Something did not match. However should_not does not make sense here"
+      end
+    
+      def description
+        "specified persistence method #{@expected_method}" 
+      end
+    
+      def calling(interface)
+        @interface = interface.to_s
+        self
+      end
+    
+      def with_uniqueness_of(attribute)
+        @options << :unique
+        @unique = attribute
+        self
+      end
+    
+      def with_destroy_key(key)
+        @options << :destroy_key
+        @destroy_key = key
+        self
+      end
+    
+      def with_destoy_type(type)
+        @options << :destroy_type
+        @destroy_type = type
+        self
+      end
+    private
+      ACCEPTABLE_OPTIONS = {
+        create: [:unique],
+        update: [],
+        destroy: [:destroy_key, :destroy_type]
+      }
+    
+      def method_supported?
+        [:create, :update, :destroy].include? @expected_method
+      end
+    
+      def acceptable_options?
+        @options.each do |option|
+          return false unless ACCEPTABLE_OPTIONS[@expected_method].include?(option)
+        end
+        true
+      end
+    
+      def interface_matches?
+        @klass.persistence_options[@expected_method].to_s == @interface
+      end
+    
+      def option_failure?
+        case @expected_method
+        when :create
+          "Expected :unique option to be equal to #{@unique}, but was #{@klass.persistence_options[:unique].inspect}" unless @klass.persistence_options[:unique] == @unique
+        when :destroy
+          if @options.include? :destroy_key
+            "Expected :destroy_key to be equal to #{@destroy_key}, but was #{@klass.send(:destroy_key).inspect}" unless @klass.send(:destroy_key) == @destroy_key
+          end
+          if @options.include? :destroy_type
+            "Expected :destroy_type to be of #{@destroy_type}, but was #{@klass.persistence_options[:destroy_type].inspect}" unless @klass.persistence_options[:destroy_type] == @destroy_type
+          end  
+        else
+          nil
+        end
+      end    
+    end    
+  end
+end

data/lib/foundation_api/table.rb

@@ -0,0 +1,6 @@
+module FoundationApi
+  module Table
+    autoload :Record,       'foundation_api/table/record'
+    autoload :Persistence,  'foundation_api/table/persistence'
+  end
+end

data/lib/foundation_api/table/persistence.rb

@@ -0,0 +1,115 @@
+require 'active_support/core_ext/hash'
+module FoundationApi
+  module Table
+    module Persistence
+      extend ActiveSupport::Concern
+      
+      included do
+        class_attribute :persistence_options        
+        # TODO: change when on rails 4
+        # delegate :remote_create, to: :class
+        delegate :remote_create, :remote_destroy, to: 'self.class'
+        self.persistence_options = {}
+      end
+      
+      module ClassMethods
+        # specify persistence support. You may specify all on one line if you like
+        # Example:
+        #
+        #   persistence create: :CreatePossession, unique: :name
+        #   persistence update: :UpdatePossession
+        #   persistence destroy: :DestroyPossession, destroy_key: possessionId
+        #
+        def persistence(options = {})
+          options.assert_valid_keys(:create, :update, :destroy, :unique, :hash_to_array, :destroy_key, :destroy_type)
+          self.persistence_options = self.persistence_options.merge(options)
+        end
+        
+        def remote_create(object)
+          unique_key = object.persistence_options[:unique]
+          if unique_key
+            existing_object = where(unique_key => object[unique_key], :deleted => 0).first
+            if existing_object
+              raise RecordNotUnique, "Record with key #{unique_key}: #{object[unique_key]} already exists"
+            end
+          end
+          id = request persistence_options[:create], object.map_attributes
+          ::Rails.logger.debug "FoundationApi::Table::Persistence.remote_create: request response: #{id.inspect}"
+          id.is_a?(Array) ? id.first : id
+        end
+        
+        def remote_destroy(*ids)
+          if persistence_options[:destroy_type] == :array
+            request persistence_options[:destroy], ids
+          else
+            ids.flatten.each do |id|
+              request persistence_options[:destroy], {destroy_key => id }
+            end
+          end
+        end
+        
+        def create(attributes = {})
+          new(attributes).save
+        end
+        def create!(attributes = {})
+          new(attributes).save!
+        end
+        
+        def destroy(*ids)
+          remote_destroy *ids
+        end
+        
+      private
+        def destroy_key
+          persistence_options[:destroy_key] || name.sub(/.*::([_a-zA-Z]+)$/, '\1').camelcase(:lower) + 'Id'
+        end
+      end
+
+      def save(options = {})
+        check_persistence_support rescue false
+        self[:id] ||= remote_create(self)
+        ::Rails.logger.debug "FoundationApi::Table::Persistence.save: after save: #{self.inspect}"
+        self
+      end
+  
+      def save!(options = {})
+        check_persistence_support
+        self.save || raise( RecordNotSaved)
+      end
+  
+      def persisted?
+        !!self[:id] 
+      end
+  
+      def new_record?
+        !persisted?
+      end
+    
+      def map_attributes
+        if persistence_options[:hash_to_array]
+          Hash[attributes.collect { |key, value| [key, value.is_a?( Hash) ? value.to_a : value] } ]
+        else
+          attributes
+        end
+      end
+    
+      def destroy
+        raise DestroyNotSupported unless persistence_options[:destroy]
+        persisted? && remote_destroy(self.id)
+      end
+      
+      def destroy!
+        raise RecordNotPersistent unless persisted?
+        destroy || raise(RecordNotDeleted)
+      end
+    
+    private
+      def check_persistence_support
+        raise CreateNotSupported if new_record? && !persistence_options[:create]
+        raise UpdateNotSupported if !new_record? && !persistence_options[:update]
+      end
+    end
+  end
+end
+
+    

data/lib/foundation_api/table/record.rb

@@ -0,0 +1,143 @@
+require 'active_model/conversion'
+require 'active_model/naming'
+require 'active_support/core_ext/hash'
+require 'foundation_api/errors'
+module FoundationApi
+  module Table
+    class Record
+      class_attribute :database_name
+      class_attribute :table_name
+      class_attribute :caching_enabled
+      class_attribute :cache_expires
+      class_attribute :default_scope
+      class_attribute :columns
+      self.default_scope = {}
+      self.columns = []
+
+      include Request
+      include Model::AttributeMethods
+      include Model::Mapping
+      include Persistence
+      include ActiveModel::Conversion
+      extend ActiveModel::Naming
+
+      class << self
+
+        def find(*args)
+          with_optional_caching args.first do
+            res = get_table_data(fully_qualified_table_name, :filters => ["id = #{args.first}"])
+            res && res.size > 0 ? instantiate_objects(res).first : nil
+          end
+        end
+
+        def where(options)
+          with_optional_caching :where, options do
+            if options.is_a? Hash
+              options = {:conditions => options }
+            end
+            res = get_table_data(fully_qualified_table_name, translate_options(options))
+            res && instantiate_objects(res) 
+          end or []
+        end
+
+        def all
+          with_optional_caching :all do
+            res = get_table_data(fully_qualified_table_name)
+            res && instantiate_objects(res) 
+          end
+        end
+
+        def with_optional_caching(*args)
+          raise ArgumentError, "You must specify block" unless block_given?
+          if caching_enabled
+            options = cache_expires ? {expires_in: cache_expires} : {}
+            Rails.cache.fetch([self.name] + args, options) do
+              yield
+            end
+          else
+            yield
+          end
+        end
+
+      private
+        def get_table_data(table, options = {})
+          options[:columns] = columns if columns && !options.has_key?( :columns)
+          options[:columns] = translate_columns(options[:columns]) if options[:columns]
+          res = request "GetTableData", options.merge(:table => table)
+          if res.is_a? Hash
+            cols = res['columnNames']
+            res['rows'].collect do |r| 
+              h = HashWithIndifferentAccess.new
+              cols.size.times do |i|
+                h[cols[i]] = r['fields'][i]
+              end
+              h
+            end
+          else
+            nil
+          end
+        end
+
+        def instantiate_objects(data)
+          data.collect { |attributes| new(:no_translate_attributes, attributes)  }
+        end
+
+        def translate_options(*args)
+          options = args.extract_options!
+          if filter = options.delete(:conditions)
+            filter = case filter
+            when Hash
+              filter.reverse_merge(default_scope).collect do |attr, value| 
+                attr == :_expression ? translate_string(value) : "#{map_attribute(attr)} = #{quote(value)}"
+              end
+            when Array
+              filter
+            when String
+              [filter.split(' ').collect { |word| map_attribute(word) }.join(' ')]
+            else
+              raise TranslationError, "Dirty filter. Cannot translate"
+            end
+          else
+            filter = [translate_string(args.first)]
+          end
+          options.merge(:filters => filter)
+        end
+
+        def translate_columns(columns)
+          columns.collect { |word| word.to_s.split(/\s+/).collect{ |w| map_attribute(w) }.join(' ') }
+        end
+        
+        def translate_string(str)
+          str.split(' ').collect { |word| map_attribute(word) }.join(' ')
+        end
+
+        def fully_qualified_table_name
+          @fully_qualified_table_name ||= begin
+            self.database_name ||= name.sub(/^([_a-zA-Z]+)::.+/, '\1').downcase
+            self.table_name ||= name.sub(/.*::([_a-zA-Z]+)$/, '\1')
+            "#{database_name}.#{table_name}"
+          end
+        end
+      end
+
+      # TODO: change when on rails 4
+      # delegate :with_optional_caching, to: :class
+      delegate :with_optional_caching, to: 'self.class'
+
+      def initialize(*args)
+        attributes = args.extract_options!
+        if args.first == :no_translate_attributes
+          @attributes = HashWithIndifferentAccess.new attributes
+        else
+          @attributes = translate_attributes attributes
+        end
+      end
+
+      def id
+        @id ||= self[:id].to_i
+      end
+      
+    end
+  end
+end
+