flexible_api 0.0.1

data/lib/flexible_api/no_such_request_level_error.rb

@@ -0,0 +1,15 @@
+module FlexibleApi
+
+  class NoSuchRequestLevelError < StandardError
+
+    def initialize(rl_name, klass_name)
+      @message = "There is no request level '#{rl_name}' for #{klass_name}"
+    end
+
+    def message
+      @message
+    end
+
+  end
+
+end

data/lib/flexible_api/request_level.rb

@@ -0,0 +1,118 @@
+module FlexibleApi
+
+  class RequestLevel
+
+    def initialize(name, klass)
+      @name = name
+      @klass = klass
+      @display_fields = Set.new
+      @select_fields = Set.new
+      @includes = []
+      @notations = {}
+      @eaten_levels = []
+      @select_fields << "`#{@klass.table_name}`.#{@klass.primary_key}" # auto-select primary key
+    end
+
+    attr_reader :display_fields, :name, :notations
+
+    def to_hash
+      {
+        :name => @name,
+        :fields => select_field + notations.keys,
+        :includes => @includes.map do |inc|
+          { :name => inc[:name], :type => inc[:association].name.to_s.pluralize.underscore.downcase, :request_level => inc[:request_level].name }
+        end
+      }
+    end
+
+    def eat_level(name)
+      @eaten_levels << @klass.find_level(name)
+    end
+
+    def notation(notation_name, options = {}, &block)
+      options.assert_valid_keys :requires
+      requires *options[:requires]
+      @notations[notation_name] = block
+    end
+
+    def includes(association_name, options = {})
+      options.assert_valid_keys :request_level, :as, :requires
+      association = @klass.reflect_on_all_associations.detect { |a| a.name == association_name.to_sym }
+      raise "No such association on #{@klass.name}: #{association_name}" if association.nil? # TODO
+      # Allow requires to pass in
+      requires *options[:requires] if options.has_key?(:requires)
+      # Set the include options
+      @includes << { 
+        :name => options[:as] || association_name,
+        :association => association, 
+        :request_level => association.klass.find_level(options[:request_level])
+      }
+    end
+
+    def requires(*requires_array)
+      requires_array.each do |field|
+        if field.is_a?(String)
+          @select_fields << field
+        else
+          @select_fields << "`#{@klass.table_name}`.#{field}" if @klass.columns_hash.keys.include?(field.to_s)
+        end
+      end
+    end
+
+    def all_fields
+      fields *@klass.columns_hash.keys.map(&:to_sym)
+    end
+
+    def fields(*field_array)
+      field_array.each do |field|
+        if field.is_a?(String)
+          @display_fields << field.split('.').last.to_sym
+          @select_fields << field
+        else
+          @display_fields << field
+          @select_fields << "`#{@klass.table_name}`.#{field}" if @klass.columns_hash.keys.include?(field.to_s)
+        end
+      end
+    end
+
+    #################################################
+
+    def select_field
+      @select_field_array ||= begin
+        selects = @select_fields.to_a
+        @eaten_levels.each { |l| selects.concat l.select_field }
+        selects
+      end
+    end
+
+    def include_field
+      @include_field_array ||= begin
+        includes = @includes.map { |i| i[:association].name }
+        @eaten_levels.each { |l| includes.concat l.include_field }
+        includes
+      end
+    end
+
+    def receive(item)
+      return nil if item.nil? # method may be nil
+      attributes = {}
+      @eaten_levels.each do |level|
+        attributes.merge! level.receive(item)
+      end
+      @display_fields.each do |field|
+        attributes[field] = item.send(field)
+      end
+      @includes.each do |include|
+        value = item.send(include[:association].name)
+        value = value.is_a?(Enumerable) ? value.map { |e| include[:request_level].receive(e) } : include[:request_level].receive(value)
+        attributes[include[:name]] = value
+      end
+      @notations.each do |name, block|
+        attributes[name] = item.instance_eval(&block)
+      end
+      attributes
+    end
+
+  end
+
+end

data/lib/flexible_api/version.rb

@@ -0,0 +1,5 @@
+module FlexibleApi
+
+  VERSION = '0.0.1'
+
+end

data/lib/flexible_api.rb

@@ -0,0 +1,86 @@
+module FlexibleApi
+
+  autoload :RequestLevel, File.dirname(__FILE__) + '/flexible_api/request_level'
+  autoload :NoSuchRequestLevelError, File.dirname(__FILE__) + '/flexible_api/no_such_request_level_error'
+
+  @@flexible_models = []
+
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+    base.send(:include, InstanceMethods)
+    @@flexible_models << base
+  end
+
+  def self.flexible_models
+    @@flexible_models
+  end
+
+  module ClassMethods
+
+    def request_levels
+      @levels.nil? ? [] : @levels.keys
+    end
+
+    # Define a request level for this class
+    # Takes a name, and a block which defined the request level
+    def define_request_level(name, &block)
+      level = RequestLevel.new(name, self)
+      level.instance_eval &block
+      @levels ||= {}
+      @levels[name] = level
+    end
+
+    # Find a single element and load it at the given request level
+    def find_hash(id, options = {})
+      options.assert_valid_keys(:request_level)
+      level = find_level(options[:request_level])
+      record = self.find(id, :select => level.select_field.join(', '), :include => level.include_field)
+      level.receive record
+    end
+
+    # Find all of an element (or association) and load it at the given request level
+    def find_all_hash(options = {})
+      options.assert_valid_keys(:request_level)
+      level = find_level(options[:request_level])
+      records = self.all(:select => level.select_field.join(', '), :include => level.include_field)
+      records.map { |r| level.receive(r) }
+    end
+
+    def default_request_level(level_name)
+      @default_request_level_name = level_name
+    end
+
+    # Find a given level by name and return the request level
+    def find_level(name = nil)
+      @levels ||= {}
+      level = name.nil? ? load_default_request_level : @levels[name.to_sym]
+      raise NoSuchRequestLevelError.new(name, self.name) if level.nil?
+      level
+    end
+
+    private
+
+    def load_default_request_level
+      @default_request_level ||= 
+        if @default_request_level_name.nil?
+          level = RequestLevel.new(:default, self)
+          level.all_fields
+          level
+        else
+          self.find_level(@default_request_level_name)
+        end
+    end
+
+  end
+
+  module InstanceMethods
+
+    # Return a hash of this element at the given request level (by name)
+    def to_hash(level_name)
+      level = self.class.find_level level_name
+      level.receive self
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:database => 'spec/test.db', :adapter => 'sqlite3')
+
+# require 'logger'
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+require File.dirname(__FILE__) + '/../lib/flexible_api'

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: flexible_api
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- John Crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: API for making APIs
+email: john.crepezzi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/flexible_api/no_such_request_level_error.rb
+- lib/flexible_api/request_level.rb
+- lib/flexible_api/version.rb
+- lib/flexible_api.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/seejohnrun/flexible_api
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: flexible_api
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A flexible API for making APIs
+test_files: 
+- spec/spec_helper.rb