classproxy 0.7.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Pablo Fernandez
+
+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/README.md

@@ -0,0 +1,131 @@
+class-proxy
+===========
+
+A generic (yet ActiveRecord compliant) class proxy to setup proxy methods for your classes.
+
+## Using
+
+The `ClassProxy` module just needs to be included in a class to get the capabilities
+provided by this gem.
+
+### Example
+
+```ruby
+class UserDb
+  include MongoMapper::Document
+  include ClassProxy
+
+  primary_fetch  { |args| where(args).first or (raise NotFound) }
+  fallback_fetch { |args| Octokit.user(args[:username]) }
+  after_fallback_fetch { |obj| UserDb.new(username: obj.login) }
+
+  key :name, String
+  key :reverse_name, String
+  key :username, String
+  key :public_repos, String
+  key :username_uppercase, String
+
+  # Use fallback_fetch since obj is requested
+  proxy_methods reverse_name: lambda { |obj| obj.name.reverse }
+
+  # No obj in the lambda, use the UserDb#username method here
+  proxy_methods username_uppercase: lambda { username.upcase }
+end
+```
+
+With this class now the following can be done:
+
+```ruby
+> user = UserDb.fetch(username: 'heelhook')
+=> #<UserDb _id: 779813, name: "Pablo Fernandez", public_repos: "25", username: "heelhook">
+```
+
+Since `Octokit.user` returned an object which responded to `name` and our `UserDb` class
+has a corresponding attribute, `:name` was set for us.
+
+```ruby
+> user.name
+=> "Pablo Fernandez"
+```
+
+Yet `reverse_name` is not included, so when we call it, the `proxy_method` associated with it
+is used.
+
+```ruby
+> user.reverse_name
+=> "zednanreF olbaP"
+```
+
+Since that `proxy_method`'s `lambda` requested an `|obj|`, the method `fallback_fetch` was used
+and the object returned is used for `obj.name.reverse`
+
+#### Using `proxy_methods` without new `fallback_fetch` calls
+
+Let's see what's currently loaded.
+
+```ruby
+> user.no_proxy_username_uppercase
+=> nil
+```
+
+Using the proxy. We already have the username in our object, so our `username_uppercase` proxy method will
+just use that (no `|obj|` is used).
+
+```ruby
+> user.username_uppercase
+=> "HEELHOOK"
+```
+
+#### Saving
+
+Here the `fallback_fetch` will not be used since the object has been persisted.
+
+```ruby
+> user.save
+=> true
+> user = UserDb.fetch(username: 'heelhook')
+=> #<UserDb _id: 779813, name: "Pablo Fernandez", public_repos: "25", username: "heelhook">
+```
+
+Like any
+
+## Compatibility
+
+ClassProxy is tested against MRI 1.9.3.
+
+## Credits
+
+Pablo Fernandez: heelhook at littleq . net
+
+## Contributing
+
+Once you've made your great commits:
+
+1. Fork
+2. Create a topic branch - `git checkout -b my_branch`
+3. Push to your branch - `git push origin my_branch`
+4. Create a [Pull Request](https://help.github.com/pull-requests/) from your branch
+5. That's it!
+
+## License
+
+Copyright (c) 2012 Pablo Fernandez
+
+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/Rakefile

@@ -0,0 +1,33 @@
+require "bundler"
+
+Bundler.setup
+Bundler.require(:default)
+require 'rake'
+require 'rspec/core/rake_task'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'classproxy/version'
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+desc "Run watchr"
+task :watchr do
+  sh %{bundle exec watchr .watchr}
+end
+
+task gem: :build
+task :build do
+  system "gem build classproxy.gemspec"
+end
+
+task release: :build do
+  version = ClassProxy::VERSION
+  system "git tag -a v#{version} -m 'Tagging #{version}'"
+  system "git push --tags"
+  system "gem push classproxy-#{version}"
+  system "rm classproxy-#{version}"
+end
+
+task default: :spec

data/lib/classproxy/classproxy.rb

@@ -0,0 +1,160 @@
+# This module provides a primitive for data models to establish a main
+# data source (as a cache or for any data conversion/merging operation)
+module ClassProxy
+  extend ActiveSupport::Concern
+
+  class NotFound < StandardError; end
+
+  module ClassMethods
+    # This method establishes how a the cache should be hit, it receives a
+    # hash with the data used for the query. If this method doesn't find
+    # anything the fallbacks will be triggered
+    #
+    # @example Use with Active Record
+    #   model.primary_fetch { |query| where(query).first }
+    def primary_fetch(&block); @primary_fetch = block; end
+
+    # Method used as fallback when the cache misses a hit fetch
+    #
+    # @example Using Github API for queries
+    #   class GithubUser
+    #     include ClassProxy
+    #
+    #     fallback_fetch { |args| Octokit.user(args[:login]) }
+    #   end
+    def fallback_fetch(&block); @fallback_fetch = block; end
+
+    # Method that post-processes fallbacks, useful to reconvert data
+    # from a fallback format into the model format
+    #
+    # @example Store Github API name in a different attribute
+    #   class GithubUser
+    #     include ClassProxy
+    #
+    #     fallback_fetch { |args| Octokit.user(args[:login]) }
+    #     after_fallback_fetch do |obj|
+    #       # obj is what `fallback_fetch` returns
+    #       GithubUser.new(name: obj.name, login: obj.login)
+    #     end
+    #
+    #     attr_accessor :name, :login
+    #   end
+    def after_fallback_fetch(&block); @after_fallback_method = block; end
+
+    # Establish attributes to proxy along with an alternative proc of how
+    # the attribute should be loaded
+    #
+    # @example Load method using uppercase
+    #   class GithubUser
+    #     include ClassProxy
+    #
+    #     fallback_fetch { |args| Octokit.user(args[:login]) }
+    #     after_fallback_fetch { |obj| GithubUser.new(name: obj.name, login: obj.login) }
+    #
+    #     attr_accessor :name, :login
+    #
+    #     proxy_methods uppercase_login: lambda { login.upcase }
+    #   end
+    #
+    #   user = GithubUser.find(login: 'heelhook')
+    #   user.login           # -> 'heelhook'
+    #   user.uppercase_login # -> 'HEELHOOK'
+    def proxy_methods(*methods)
+      @_methods ||= {}
+
+      methods.each do |method|
+        if method.is_a? Symbol
+          # If given a symbol, store as a method to overwrite and use the default loader
+          proxy_method method, @default_proc
+        elsif method.is_a? Hash
+          # If its a hash it will include methods to overwrite along with
+          # custom loaders
+          method.each { |method_name, proc| proxy_method method_name, proc }
+        end
+      end
+    end
+
+    # Method to find a record using a hash as the criteria
+    #
+    # @example
+    #   class GithubUser
+    #     include MongoMapper::Document
+    #     include ClassProxy
+    #
+    #     primary_fetch  { |args| where(args).first or (raise NotFound) }
+    #     fallback_fetch { |args| Octokit.user(args[:login]) }
+    #   end
+    #
+    #   GithubUser.fetch(login: 'heelhook') # -> Uses primary_fetch
+    #                                       # -> and, if NotFound, fallback_fetch
+    #
+    # @param [ Hash ] args The criteria to use
+    # @options options [ true, false] :skip_fallback Don't use fallback methods
+    def fetch(args, options={})
+      @primary_fetch.is_a?(Proc) ? @primary_fetch.call(args) : (raise NotFound)
+    rescue NotFound
+      return nil if options[:skip_fallback]
+
+      fallback_obj = @fallback_fetch.call(args)
+
+      # Use the after_fallback_method
+      obj = @after_fallback_method.is_a?(Proc) ? @after_fallback_method[fallback_obj] : self.new
+
+      # Go through the keys of the return object and try to use setters
+      if fallback_obj and obj and fallback_obj.respond_to? :keys and fallback_obj.keys.respond_to? :each
+        fallback_obj.keys.each do |key|
+          next unless obj.respond_to? "#{key}="
+          obj.send("#{key}=", fallback_obj.send(key))
+        end
+      end
+
+      return obj
+    end
+
+    private
+
+    def proxy_method(method_name, proc)
+      self.class_eval do
+        alias_method "no_proxy_#{method_name}".to_sym, method_name
+
+        define_method(method_name) do |*args|
+          # Use the no_proxy one first
+          v = self.send("no_proxy_#{method_name}".to_sym, *args)
+
+          # TODO -- Cache if this also returned nil so the fallback is not used
+          #         constantly on actual nil values
+
+          # Since AR calls the getter method when using the setter method
+          # to establish the dirty attribute, since the getter is being replaced
+          # here and the setter is being used when appropriate, the @mutex_in_call_for
+          # prevents endless recursion.
+          if v == nil and @mutex_in_call_for != method_name
+            @mutex_in_call_for = method_name
+            method = "_run_fallback_#{method_name}".to_sym
+            v = if self.method(method).arity == 1
+              fallback_fetch_method = self.class.instance_variable_get(:@fallback_fetch)
+              fallback_obj = fallback_fetch_method.call(self)
+              self.send(method, fallback_obj)
+            else
+              self.send(method)
+            end
+            self.send("#{method_name}=".to_sym, v) if v and self.respond_to?("#{method_name}=")
+            @mutex_in_call_for = nil
+          end
+
+          return v
+        end
+      end
+
+      # Now define the fallback that is going to be used
+      self.send(:define_method, "_run_fallback_#{method_name}", &proc)
+    end
+  end
+
+  @default_proc = Proc.new { "hi" }
+
+  def self.included(receiver)
+    receiver.extend ClassMethods
+
+  end
+end

data/lib/classproxy/version.rb

@@ -0,0 +1,3 @@
+module ClassProxy
+  VERSION = '0.7.0'
+end

data/lib/classproxy.rb

@@ -0,0 +1,2 @@
+require 'classproxy/classproxy'
+require 'classproxy/version'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: classproxy
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+  prerelease: 
+platform: ruby
+authors:
+- Pablo Fernandez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A generic (yet ActiveRecord compliant) class proxy to setup proxy methods
+  for your classes
+email:
+- heelhook@littleq.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/classproxy/classproxy.rb
+- lib/classproxy/version.rb
+- lib/classproxy.rb
+- LICENSE
+- README.md
+- Rakefile
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1757276134507409389
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A generic class proxy for your classes
+test_files: []