rep 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in representative.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 myobie
+
+MIT License
+
+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,168 @@
+# Rep
+
+```
+                               /T /I
+                              / |/ | .-~/
+                          T\ Y  I  |/  /  _
+         /T               | \I  |  I  Y.-~/
+        I l   /I       T\ |  |  l  |  T  /
+ __  | \l   \l  \I l __l  l   \   `  _. |
+ \ ~-l  `\   `\  \  \\ ~\  \   `. .-~   |
+  \   ~-. "-.  `  \  ^._ ^. "-.  /  \   |
+.--~-._  ~-  `  _  ~-_.-"-." ._ /._ ." ./
+ >--.  ~-.   ._  ~>-"    "\\   7   7   ]
+^.___~"--._    ~-{  .-~ .  `\ Y . /    |
+ <__ ~"-.  ~       /_/   \   \I  Y   : |
+   ^-.__           ~(_/   \   >._:   | l______
+       ^--.,___.-~"  /_/   !  `-.~"--l_ /     ~"-.
+              (_/ .  ~(   /'     "~"--,Y   -=b-. _)
+               (_/ .  \  :           / l      c"~o \
+                \ /    `.    .     .^   \_.-~"~--.  )
+                 (_/ .   `  /     /       !       )/
+                  / / _.   '.   .':      /        '
+                  ~(_/ .   /    _  `  .-<_
+                    /_/ . ' .-~" `.  / \  \          ,z=.
+                    ~( /   '  :   | K   "-.~-.______//
+                      "-,.    l   I/ \_    __{--->._(==.
+                       //(     \  <    ~"~"     //
+                      /' /\     \  \     ,v=.  ((
+                    .^. / /\     "  }__ //===-  `
+                   / / ' '  "-.,__ {---(==-
+                 .^ '       :  T  ~"   ll
+                / .  .  . : | :!        \\
+               (_/  /   | | j-"          ~^
+                 ~-<_(_.^-~"
+```
+
+A library for writing authoritative representations of objects for pages and apis.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rep'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rep
+
+## Usage
+
+`include Rep` into any class and it is endowed with a `#to_json` method,
+among other things. You describe the top level keys you want for your
+json with the `::fields` method. The values for the fields are expected
+to be returned from methods on the object of the same name.
+
+If a class has `fields :one => :default`, then `def one; 1; end` is
+expected.
+
+## Examples
+
+```ruby
+# imagine Photo is an ActiveRecord model with fields for title, exif, location, and user_id
+
+class PhotoRep
+  include Rep
+
+  initialize_with :photo
+
+  json_fields [:url, :title, :exif, :location, :user] => :default
+
+  forward [:title, :exif, :location] => :photo
+  forward :user => :user_rep
+
+  def url
+    full_photo_url(photo.name)
+  end
+
+  def user
+    UserRep.shared(user: photo.user)
+  end
+end
+
+# imagine User is an ActiveRecord model with fields for name, email, and location
+
+class UserRep
+  include Rep
+
+  initialize_with :user
+
+  json_fields [:name, :email, :location] => :default
+  json_fields [:id, :admin].concat(json_fields(:default)) => :admin
+
+  forward json_fields(:admin) => :user
+end
+
+# You can now do crazy stuff like
+
+UserRep.new(user: User.first).to_hash.keys # => [:name, :email, :location]
+
+# To save from creating lots of objects, you can use a shared class that is reset fresh
+UserRep.shared(user: User.first).to_hash # => { name: "Nathan Herald:, ...
+
+# You can use class to proc (that makes a hash using the shared class)
+User.all.map(&UserRep) # => [{ name: "Nathan Herald" ...
+
+# or maybe find all photos which will embed all users (and only ever make one instance each of PhotoRep and UserRep)
+Photo.all.map(&PhotoRep).to_json
+```
+
+### Any class
+
+You don't have to have a Rep per model and Rep's can represent multiple objects at once. It's POROs.
+
+```ruby
+class ProjectReport
+  initialize_with :project, :active_users, :orders
+  fields [:name, :date, :count, :total_gross_cost, :cost_per_active_user]
+  forward :date => :project
+  forward :count => :orders
+
+  def name
+    "#{project.name} Report"
+  end
+
+  def total_gross_cost
+    orders.reduce(0.0) { |memo, order| memo += order.total_gross_cost.to_f }
+  end
+
+  def cost_per_active_user
+    active_users.count.to_f / total_gross_cost.to_f
+  end
+end
+```
+
+### Hashie
+
+If you have the hashie gem in your project, `#to_hash` returns a `Hashie::Mash` instance.
+
+```ruby
+UserRep.new(user: User.first).to_hash.class # => Hashie::Mash
+
+# which lets you do the dot accessors for things
+@user = UserRep.new(user: User.first).to_hash
+@user.name # => "Nathan Herald"
+```
+
+### Rails
+
+A possible controller
+```ruby
+class PhotosController < ApplicationController
+  respond_to :json, :html
+
+  def index
+    @photos = Photo.paginate(page: params[:page], per_page: 20)
+    respond_with @photos.map(&PhotoRep)
+  end
+
+  def show
+    @photo = Photo.find(params[:id])
+    respond_with PhotoRep.new(photo: @photo)
+  end
+end
+```

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+task default: 'test'

data/lib/rep/version.rb

@@ -0,0 +1,3 @@
+module Rep
+  VERSION = "0.0.1"
+end

data/lib/rep.rb

@@ -0,0 +1,150 @@
+require "rep/version"
+require 'forwardable'
+require 'json'
+
+module Rep
+  def self.included(klass)
+    klass.extend Forwardable
+    klass.extend ClassMethods
+    klass.instance_eval {
+      class << self
+        alias forward delegate
+
+        unless defined?(fields)
+          alias fields json_fields
+        end
+
+        if defined?(Hashie)
+          include HashieSupport
+        end
+      end
+
+      unless defined?(parse_opts)
+        def parse_opts(opts = {})
+          # NOOP
+        end
+      end
+    }
+  end
+
+  def reset_for_json!
+    self.class.all_json_methods.each do |method_name|
+      instance_variable_set(:"@#{method_name}", nil)
+    end
+  end
+
+  def to_hash(name = :default)
+    if fields = self.class.json_fields(name)
+      fields.reduce({}) do |memo, field|
+        field_name, method_name = field.is_a?(Hash) ? field.to_a.first : [field, field]
+        begin
+          memo[field_name] = send(method_name)
+        rescue NoMethodError => e
+          message = "There is no method named '#{method_name}' for the class '#{self.class}' for the '#{name}' list of fields : #{e.message}"
+          raise NoMethodError.new(message, method_name, e.args)
+        end
+        memo
+      end
+    else
+      raise "There are no json fields under the name: #{name}"
+    end
+  end
+
+  def to_json
+    JSON.generate(to_hash)
+  end
+
+  module ClassMethods
+    def register_accessor(acc)
+      name, default = acc.is_a?(Hash) ? acc.to_a.first : [acc, nil]
+      attr_accessor name
+      if default
+        define_method name do
+          var_name = :"@#{name}"
+          instance_variable_get(var_name) || instance_variable_set(var_name, default)
+        end
+      end
+    end
+
+    def initialize_with(*args)
+      @initializiation_args = args
+
+      define_singleton_method :initializiation_args do
+        @initializiation_args
+      end
+
+      args.each { |a| register_accessor(a) }
+
+      define_method(:initialize) { |opts = {}| parse_opts(opts) }
+
+      define_method :parse_opts do |opts|
+        @presidential_options = opts
+        self.class.initializiation_args.each do |field|
+          name = field.is_a?(Hash) ? field.to_a.first.first : field
+          instance_variable_set(:"@#{name}", opts[name])
+        end
+      end
+    end
+
+    def json_fields(arg = nil)
+      if arg.is_a?(Hash)
+        fields, name = arg.to_a.first
+        @json_fields ||= {}
+        @json_fields[name] = [fields].flatten
+      elsif arg.is_a?(Symbol)
+        @json_fields ||= {}
+        @json_fields[arg]
+      elsif arg === nil
+        @json_fields || {}
+      else
+        # TODO: make an exception class
+        raise "You can only use a Hash to set fields, a Symbol to retrieve them, or no argument to retrieve all fields for all names"
+      end
+    end
+
+    def flat_json_fields(side = :right)
+      side_number = side == :right ? 1 : 0
+
+      json_fields.reduce([]) do |memo, (name, fields)|
+        memo + fields.map do |field|
+          if field.is_a?(Hash)
+            field.to_a.first[side_number] # [name, method_name]
+          else
+            field
+          end
+        end
+      end.uniq
+    end
+
+    def all_json_fields
+      flat_json_fields(:left)
+    end
+
+    def all_json_methods
+      flat_json_fields(:right)
+    end
+
+    # TODO: thread safety
+    def shared(opts = {})
+      @instance ||= new
+      @instance.reset_for_json!
+      @instance.parse_opts(opts)
+      @instance
+    end
+
+    def to_proc
+      proc { |obj|
+        arr = [obj].flatten
+        init_args = @initializiation_args[0..(arr.length-1)]
+        opts = Hash[init_args.zip(arr)]
+        shared(opts).to_hash
+      }
+    end
+  end
+
+  module HashieSupport
+    def to_hash(name = :default)
+      Hashie::Mash.new(super)
+    end
+  end
+end

data/rep.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rep/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rep"
+  gem.version       = Rep::VERSION
+  gem.authors       = ["myobie"]
+  gem.email         = ["nathan@myobie.com"]
+  gem.description   = %q{A library for writing authoritative representations of objects for pages and apis.}
+  gem.summary       = %q{Include Rep into any object to endow it to create json (or hashes) easily.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'json'
+end

data/test/lib/rep_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+
+describe Rep do
+
+  def new_rep_class(&blk)
+    klass = Class.new
+    klass.send :include, Rep
+    if block_given?
+      klass.class_eval &blk
+    end
+    klass
+  end
+
+  it "includes forwardable" do
+    new_rep_class.must_respond_to :delegate
+  end
+
+  it "aliases delegate to foward" do
+    new_rep_class.must_respond_to :forward
+  end
+
+  it "aliases fields to json_fields" do
+    new_rep_class.must_respond_to :fields
+  end
+
+  it "has a parse_opts method" do
+    new_rep_class.must_respond_to :parse_opts
+  end
+
+  it "can have fields" do
+    klass = new_rep_class do
+      fields [:foo, :bar] => :default
+    end
+    klass.fields(:default).must_equal [:foo, :bar]
+  end
+
+  it "can create initialize method" do
+    klass = new_rep_class do
+      initialize_with :foo, :bar
+    end
+    inst = klass.new(foo: 'foo123')
+    inst.foo.must_equal 'foo123'
+    inst.bar.must_be_nil
+  end
+
+  it "can have default initialization options" do
+    klass = new_rep_class do
+      initialize_with :foo, { bar: "barbar" }
+    end
+    inst = klass.new(foo: 'foofoo')
+    inst.bar.must_equal 'barbar'
+  end
+
+  it "can overried default initialization options" do
+    klass = new_rep_class do
+      initialize_with :foo, { bar: "barbar" }
+    end
+    inst = klass.new(bar: 'notbar')
+    inst.bar.must_equal 'notbar'
+    inst.foo.must_be_nil
+  end
+
+  it "should accept multiple sets of fields" do
+    klass = new_rep_class do
+      fields [:one, :four] => :default
+      fields [:one, :two, :three] => :superset
+    end
+    klass.fields(:default).length.must_equal 2
+    klass.fields(:superset).length.must_equal 3
+  end
+
+  it "should know all uniq fields" do
+    klass = new_rep_class do
+      fields [:one, :four] => :default
+      fields [:one, :two, :three] => :superset
+    end
+    klass.all_json_fields.must_equal [:one, :four, :two, :three]
+  end
+
+  it "should send fields to instance to make hash" do
+    klass = new_rep_class do
+      fields [:one, :two, :three] => :default
+      def one; 1; end
+      def two; 2; end
+      def three; 3; end
+    end
+    klass.new.to_hash.must_equal one: 1, two: 2, three: 3
+  end
+
+  it "should send fields to instance to make json" do
+    klass = new_rep_class do
+      fields [:one, :two, :three] => :default
+      def one; 1; end
+      def two; 2; end
+      def three; 3; end
+    end
+    klass.new.to_json.must_equal '{"one":1,"two":2,"three":3}'
+  end
+
+  it "should let fields alias to method names" do
+    klass = new_rep_class do
+      fields [{ :one => :real_one }, :two, :three] => :default
+      def real_one; 1; end
+      def two; 2; end
+      def three; 3; end
+    end
+    klass.new.to_json.must_equal '{"one":1,"two":2,"three":3}'
+  end
+
+  it "should know all the methods for the fields" do
+    klass = new_rep_class do
+      fields [{ :one => :real_one }, :two, :three] => :default
+      def real_one; 1; end
+      def two; 2; end
+      def three; 3; end
+    end
+    klass.all_json_methods.must_equal [:real_one, :two, :three]
+  end
+
+  it "should know all the field names for the fields" do
+    klass = new_rep_class do
+      fields [{ :one => :real_one }, :two, :three] => :default
+      def real_one; 1; end
+      def two; 2; end
+      def three; 3; end
+    end
+    klass.all_json_fields.must_equal [:one, :two, :three]
+  end
+
+  it "should do symbol to instance craziness" do
+    klass = new_rep_class do
+      initialize_with :hash
+      fields :keys => :default
+      forward :keys => :hash
+    end
+    hashes = [{ one: 1, two: 2 },
+              { three: 3, four: 4 },
+              { one: 1, five: 5 }]
+    hashes.map(&klass).to_json.must_equal '[{"keys":["one","two"]},{"keys":["three","four"]},{"keys":["one","five"]}]'
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'rep'
+
+class User < Struct.new(:name, :email, :location)
+end
+
+class Photo < Struct.new(:name, :location, :exif)
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: rep
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- myobie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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 library for writing authoritative representations of objects for pages
+  and apis.
+email:
+- nathan@myobie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rep.rb
+- lib/rep/version.rb
+- rep.gemspec
+- test/lib/rep_test.rb
+- test/test_helper.rb
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Include Rep into any object to endow it to create json (or hashes) easily.
+test_files:
+- test/lib/rep_test.rb
+- test/test_helper.rb