dao 5.5.1 → 8.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8027aaf83bcaae5677e03b94f45a721af6e0a9b85452a495757bca6fda993775
+  data.tar.gz: 904f11383d38fe16ad1c03013e986ee12abab72b60bfa2e86420c3681ad5e0a1
+SHA512:
+  metadata.gz: 7ae990d1a7101ef449a2d09ab244221071fa7b5d9abb6b261c23e74f7410d9a710a437f458aec91475811b451a14fc5e982c11fda9e268550395e5eb2793cfa3
+  data.tar.gz: 49ce79df7587bdf270d72e08f2f0f7586efb1fd9573feb63a9996a74a2df62dd5f5a2536b08bcebb329be3730d5fef8f77c2b40e0a5f7dc703649235a091ef9b

data/README.md

@@ -0,0 +1,258 @@
+# dao
+
+## SYNOPSIS
+
+a sa-weet-ass library for structuring rails applications using the 'data
+access object' design pattern.  dao consists of two main data access
+objects, *api* objects and *conducer* objects.  conducers combine the
+presenter pattern with the conductor pattern.
+
+
+### API
+
+    class Api < Dao::Api
+      call('/posts') do
+        get do
+          data[:posts] = Post.all.map{|post| post.attributes}
+        end
+
+        post do
+          post = Post.new(params[:post])
+
+          if post.save
+            data[:post] = post.attributes
+          else
+            status 420
+          end
+        end
+      end
+    end
+
+### CONDUCER
+
+  * TODO
+
+wikipedia has this to say about dao in general
+
+  >
+  > In computer software, a data access object (DAO) is an object that
+  > provides an abstract interface to some type of database or other
+  > persistence mechanism. By mapping application calls to the persistence
+  > layer, DAOs provide some specific data operations without exposing
+  > details of the database. This isolation supports the single
+  > responsibility principle. It separates what data accesses the
+  > application needs, in terms of domain-specific objects and data types
+  > (the public interface of the DAO), from how these needs can be satisfied
+  > with a specific DBMS, database schema, etc. (the implementation of the
+  > DAO).
+  >
+  -- http://en.wikipedia.org/wiki/Data_access_object
+
+and this to say about the single responsibility principle
+
+  >
+  > In object-oriented programming, the single responsibility principle
+  > states that every class should have a single responsibility, and that
+  > responsibility should be entirely encapsulated by the class. All its
+  > services should be narrowly aligned with that responsibility.
+
+  > Responsibility [is defined] as a reason to change, and [single
+  > responsibility means] that a class or module should have one, and only
+  > one, reason to change. As an example, consider a module that compiles and
+  > prints a report. Such a module can be changed for two reasons. First,
+  > the content of the report can change. Second, the format of the report
+  > can change. These two things change for very different causes; one
+  > substantive, and one cosmetic. The single responsibility principle says
+  > that these two aspects of the problem are really two separate
+  > responsibilities, and should therefore be in separate classes or
+  > modules. It would be a bad design to couple two things that change for
+  > different reasons at different times.
+  >
+  -- http://en.wikipedia.org/wiki/Single_responsibility_principle
+
+even though rails is the sweet, its ActiveRecord class violates (or, at
+least, encourages a programmer to violate) the single responsibility
+principle
+
+this leads to obvious problems
+
+  >
+  > Jim Weirich, at the end of his SOLID Ruby Talk at the 2009 Ruby
+  > Conference, asks the audience: "ActiveRecord objects implement a domain
+  > concept and a persistence concept. Does this violate the SRP (Single
+  > Responsibility Principle)?" The audience agrees that it does violate the
+  > SRP. Jim asks if this bothers them. Many members of the audience say
+  > yes. Why? It makes testing harder. It makes the persistence object a lot
+  > heavier.
+  >
+  -- http://programmers.stackexchange.com/questions/119352/does-the-activerecord-pattern-follow-encourage-the-solid-design-principles#comment293734_119352
+
+and subtle yet sweeping consequences (as described by uncle bob)
+
+  >
+  > The problem I have with ActiveRecord is that it creates confusion about
+  > ... two very different styles of programming. A database table is a
+  > data structure. It has exposed data and no behavior. But an ActiveRecord
+  > appears to be an object. It has “hidden” data, and exposed behavior. I
+  > put the word “hidden” in quotes because the data is, in fact, not
+  > hidden. Almost all ActiveRecord derivatives export the database columns
+  > through accessors and mutators. Indeed, the Active Record is meant to be
+  > used like a data structure.
+
+  > On the other hand, many people put business rule methods in their
+  > ActiveRecord classes; which makes them appear to be objects. This leads
+  > to a dilemma. On which side of the line does the Active Record really
+  > fall? Is it an object? Or is it a data structure?
+
+  > This dilemma is the basis for the oft-cited impedance mismatch between
+  > relational databases and object oriented languages. Tables are data
+  > structures, not classes. Objects are encapsulated behavior, not database
+  > rows.
+
+  > ...
+
+  > The problem is that Active Records are data structures. Putting business
+  > rule methods in them doesn’t turn them into true objects. In the end,
+  > the algorithms that employ ActiveRecords are vulnerable to changes in
+  > schema, and changes in type. They are not immune to changes in type, the
+  > way algorithms that use objects are.
+
+  > ...
+
+  > So applications built around ActiveRecord are applications built around
+  > data structures. And applications that are built around data structures
+  > are procedural—they are not object oriented. The opportunity we miss
+  > when we structure our applications around ActiveRecord is the
+  > opportunity to use object oriented design.
+  >
+  -- https://sites.google.com/site/unclebobconsultingllc/active-record-vs-objects
+
+and a clear solution (again, uncle bob)
+
+  > I am not recommending against the use of ActiveRecord. I think the
+  > pattern is very useful. What I am advocating is a separation between the
+  > application and ActiveRecord.
+
+  > ActiveRecord belongs in the layer that separates the database from the
+  > application. It makes a very convenient halfway-house between the hard
+  > data structures of database tables, and the behavior exposing objects in
+  > the application.
+
+  > Applications should be designed and structured around objects, not data
+  > structures. Those objects should expose business behaviors, and hide any
+  > vestige of the database.
+  >
+  -- https://sites.google.com/site/unclebobconsultingllc/active-record-vs-objects
+
+welcome to the dao
+
+
+## DESCRIPTION
+
+### API
+
+applications that are written on dao look like this in ruby
+
+      result = api.call('/posts/new', params)
+
+and like this in javascript
+
+      result = api.call('/posts/new', params)
+
+in command-line applications they look like this
+
+      result = api.call('/posts/new', params)
+
+and in tests this syntax is used
+
+      result = api.call('/posts/new', params)
+
+when a developer wants to understand the interface of a dao application she does
+this
+
+      vi app/api.rb
+
+when a developer of a dao application wants to play with a dao application
+interactively she does
+
+      (rails console)
+
+      > api = Api.new result = api.call('/posts/new', params)
+
+when a remote client wants to understand the api of a dao application she
+does
+
+      curl --silent http://dao.app.com/api | less
+
+
+
+this kind of brutally consistent interface is made possible by structuring
+access to data around the finest data structure of all time - the hash.
+in the case of dao the hash is a well structured and slightly clever hash,
+but a simple hash interface is the basis of every bit of goodness dao has
+to offer.
+
+in dao, application developers do not bring models into controllers and,
+especially not into views.  instead, a unified interface to application
+logic and data is used everywhere: in tests, in controllers, from the
+command-line, and also from javascript.
+
+this seperation of concerns brings with it many, many desirable qualities:
+
+  - total seperation of concerns between the front and back end of a web
+    application.  when developers are using dao changes to the data model
+    have zero effect on controllers and views.
+
+  - issues related to having models in controllers and views such as
+    difficulty reasoning about caching and n+1 queries in views killing
+    the db simply disappear.
+
+  - bad programming practices like using quasi-global variables
+    (current_user) or decorating models with view specific attributes
+    (password_verification) are no longer needed.
+
+  - developers are able to reason over the abilities of an application by
+    reading only a few source files.
+
+  - databases can be swapped, mixed, or alternate storage/caching
+    mechanisms added at any time without affecting the application's
+    controllers or views.
+
+  - transition from form based views to semi-ajax ones to fully-ajax ones
+    is direct.
+
+  - forms and interfaces that involve dozens of models are as easy to deal
+    with as simple ones.
+
+  - code can be optimized at the interface.
+
+## READING
+
+  * http://blog.plataformatec.com.br/2012/03/barebone-models-to-use-with-actionpack-in-rails-4-0/
+  * http://martinfowler.com/eaaCatalog/serviceLayer.html
+  * http://blog.firsthand.ca/2011/10/rails-is-not-your-application.html
+  * http://best-practice-software-engineering.ifs.tuwien.ac.at/patterns/dao.html
+  * http://www.codefutures.com/data-access-object/
+  * http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html
+  * http://www.paperplanes.de/2010/5/7/activerecord_callbacks_ruined_my_life.html
+  * http://google-styleguide.googlecode.com/svn/trunk/jsoncstyleguide.xml
+  * http://pragdave.blogs.pragprog.com/pragdave/2007/03/the_radar_archi.html
+  * http://borisstaal.com/post/22586260753/mvc-in-a-browser-vs-reality
+
+
+## INSTALL
+
+    gem 'dao', :path => File.expand_path('..') ### Gemfile
+    rails generate dao api
+    vim -o app/api.rb app/controllers/api_controller.rb
+    curl --silent http://0.0.0.0:3000/api
+    curl --silent http://0.0.0.0:3000/api/ping
+
+## HISTORY
+
+###  4.0.0
+  - dao depends has tied itself to rails, for better or worse...
+  - drop custom form encoding.  just use a rack-like approach.
+  - dao form parameter encoding has changed slightly to 'dao[/api/path][x,y,z]=42'
+  - dao form paramters are now preparsed in a before filter
+

data/Rakefile

@@ -1,10 +1,10 @@
-This.rubyforge_project = 'codeforpeople'
+#This.rubyforge_project = 'codeforpeople'
 This.author = "Ara T. Howard"
 This.email = "ara.t.howard@gmail.com"
 This.homepage = "https://github.com/ahoward/#{ This.lib }"
 
 task :license do
-  open('LICENSE', 'w'){|fd| fd.puts "same as ruby's"}
+  open('LICENSE', 'w'){|fd| fd.puts "Ruby"}
 end
 
 task :default do
@@ -32,7 +32,7 @@ def run_tests!(which = nil)
 
   test_rbs.each_with_index do |test_rb, index|
     testno = index + 1
-    command = "#{ This.ruby } -I ./lib -I ./test/lib #{ test_rb }"
+    command = "#{ This.ruby } -w -I ./lib -I ./test/lib #{ test_rb }"
 
     puts
     say(div, :color => :cyan, :bold => true)
@@ -93,7 +93,7 @@ task :gemspec do
   test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
   summary     = object.respond_to?(:summary) ? object.summary : "summary: #{ lib } kicks the ass"
   description = object.respond_to?(:description) ? object.description : "description: #{ lib } kicks the ass"
-  license     = object.respond_to?(:license) ? object.license : "same as ruby's"
+  license     = object.respond_to?(:license) ? object.license : "Ruby"
 
   if This.extensions.nil?
     This.extensions = []
@@ -145,7 +145,6 @@ task :gemspec do
 
             spec.extensions.push(*<%= extensions.inspect %>)
 
-            spec.rubyforge_project = <%= This.rubyforge_project.inspect %>
             spec.author = <%= This.author.inspect %>
             spec.email = <%= This.email.inspect %>
             spec.homepage = <%= This.homepage.inspect %>
@@ -297,7 +296,7 @@ BEGIN {
 
 # discover full path to this ruby executable
 #
-  c = Config::CONFIG
+  c = RbConfig::CONFIG
   bindir = c["bindir"] || c['BINDIR']
   ruby_install_name = c['ruby_install_name'] || c['RUBY_INSTALL_NAME'] || 'ruby'
   ruby_ext = c['EXEEXT'] || ''

data/dao.gemspec

@@ -3,22 +3,20 @@
 
 Gem::Specification::new do |spec|
   spec.name = "dao"
-  spec.version = "5.5.1"
+  spec.version = "8.0.1"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "dao"
-  spec.description = "presenter, conducer, api, and better form objects for you rails' pleasure"
-  spec.license = "same as ruby's"
+  spec.description = "presenter, conductor, api, and better form objects for you rails' pleasure"
+  spec.license = "Ruby"
 
   spec.files =
-["Gemfile",
- "Gemfile.lock",
- "README",
+["README.md",
  "Rakefile",
- "a.rb",
  "dao.gemspec",
  "lib",
  "lib/dao",
  "lib/dao.rb",
+ "lib/dao/_lib.rb",
  "lib/dao/active_record.rb",
  "lib/dao/api",
  "lib/dao/api.rb",
@@ -29,6 +27,7 @@ Gem::Specification::new do |spec|
  "lib/dao/api/modes.rb",
  "lib/dao/api/routes.rb",
  "lib/dao/blankslate.rb",
+ "lib/dao/coerce.rb",
  "lib/dao/conducer",
  "lib/dao/conducer.rb",
  "lib/dao/conducer/active_model.rb",
@@ -43,6 +42,7 @@ Gem::Specification::new do |spec|
  "lib/dao/endpoint.rb",
  "lib/dao/engine.rb",
  "lib/dao/errors.rb",
+ "lib/dao/errors2html.rb",
  "lib/dao/exceptions.rb",
  "lib/dao/extractor.rb",
  "lib/dao/form.rb",
@@ -86,8 +86,13 @@ Gem::Specification::new do |spec|
  "lib/dao/validations/common.rb",
  "lib/dao/validations/instance.rb",
  "lib/dao/validations/validator.rb",
- "notes",
- "notes/ara.txt",
+ "lib/dao/wrap.rb",
+ "public",
+ "public/system",
+ "public/system/uploads",
+ "tasks",
+ "tasks/default.rake",
+ "tasks/this.rb",
  "test",
  "test/active_model_conducer_lint_test.rb",
  "test/api_test.rb",
@@ -96,10 +101,11 @@ Gem::Specification::new do |spec|
  "test/data/han-solo.jpg",
  "test/errors_test.rb",
  "test/form_test.rb",
- "test/helper.rb",
  "test/leak.rb",
+ "test/rake_rerun_reporter.rb",
  "test/support_test.rb",
- "test/testing.rb",
+ "test/test_helper.rb",
+ "test/util.rb",
  "test/validations_test.rb"]
 
   spec.executables = []
@@ -109,30 +115,19 @@ Gem::Specification::new do |spec|
   spec.test_files = nil
 
   
-    spec.add_dependency(*["rails", " ~> 3.1"])
+    spec.add_dependency(*["rails", " ~> 6.0"])
   
-    spec.add_dependency(*["map", " >= 6.0.0"])
+    spec.add_dependency(*["map", " ~> 6.6"])
   
-    spec.add_dependency(*["fattr", " >= 2.2"])
+    spec.add_dependency(*["fattr", " ~> 2.4"])
   
-    spec.add_dependency(*["coerce", " >= 0.0.3"])
+    spec.add_dependency(*["tagz", " ~> 9.10"])
   
-    spec.add_dependency(*["tagz", " >= 9.9.2"])
-  
-    spec.add_dependency(*["multi_json", " >= 1.0.3"])
-  
-    spec.add_dependency(*["uuidtools", " >= 2.1.2"])
-  
-    spec.add_dependency(*["wrap", " >= 1.5.0"])
-  
-    spec.add_dependency(*["rails_current", " >= 1.8.0"])
-  
-    spec.add_dependency(*["rails_errors2html", " >= 1.3.0"])
+    spec.add_dependency(*["rails_current", " ~> 2.2"])
   
 
   spec.extensions.push(*[])
 
-  spec.rubyforge_project = "codeforpeople"
   spec.author = "Ara T. Howard"
   spec.email = "ara.t.howard@gmail.com"
   spec.homepage = "https://github.com/ahoward/dao"

data/lib/dao.rb

@@ -7,86 +7,49 @@
   require 'cgi'
   require 'tmpdir'
   require 'yaml'
+  require 'securerandom'
+  require 'json'
 
-# dao libs
 #
-  module Dao
-    Version = '5.5.1' unless defined?(Version)
-
-    def version
-      Dao::Version
-    end
-
-    def dependencies
-      {
-        'rails'             => [ 'rails'             , ' ~> 3.1'   ] ,
-        'map'               => [ 'map'               , ' >= 6.0.0' ] ,
-        'fattr'             => [ 'fattr'             , ' >= 2.2'   ] ,
-        'coerce'            => [ 'coerce'            , ' >= 0.0.3' ] ,
-        'tagz'              => [ 'tagz'              , ' >= 9.9.2' ] ,
-        'multi_json'        => [ 'multi_json'        , ' >= 1.0.3' ] ,
-        'uuidtools'         => [ 'uuidtools'         , ' >= 2.1.2' ] ,
-        'wrap'              => [ 'wrap'              , ' >= 1.5.0' ] ,
-        'rails_current'     => [ 'rails_current'     , ' >= 1.8.0' ] ,
-        'rails_errors2html' => [ 'rails_errors2html' , ' >= 1.3.0' ] ,
-      }
-    end
-
-    def description
-      "presenter, conducer, api, and better form objects for you rails' pleasure"
-    end
-
-    def libdir(*args, &block)
-      @libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
-      args.empty? ? @libdir : File.join(@libdir, *args)
-    ensure
-      if block
-        begin
-          $LOAD_PATH.unshift(@libdir)
-          block.call()
-        ensure
-          $LOAD_PATH.shift()
-        end
-      end
-    end
-
-    def load(*libs)
-      libs = libs.join(' ').scan(/[^\s+]+/)
-      Dao.libdir{ libs.each{|lib| Kernel.load(lib) } }
-    end
-
-    extend(Dao)
-  end
+  require_relative 'dao/_lib.rb'
 
 # gems
 #
-  begin
+  begin 
     require 'rubygems'
   rescue LoadError
     nil
   end
 
-  if defined?(gem)
-    Dao.dependencies.each do |lib, dependency|
-      gem(*dependency)
-      require(lib)
-    end
+  Dao.dependencies.each do |lib, dependency|
+    gem(*dependency) if defined?(gem)
+    require(lib)
   end
 
+# rails frameworks
+#
   %w[
     action_controller
-    active_resource
     active_support
+    active_model
   ].each do |framework|
     begin
       require "#{ framework }/railtie"
     rescue LoadError
+      begin
+        require "#{ framework }"
+      rescue LoadError
+        raise
+      end
     end
   end
 
-
+# dao libs
+#
   Dao.load %w[
     blankslate.rb
+    coerce.rb
+    wrap.rb
     instance_exec.rb
     extractor.rb
     exceptions.rb
@@ -97,6 +60,7 @@
     name.rb
     status.rb
     path_map.rb
+    errors2html.rb
     errors.rb
     messages.rb
     form.rb
@@ -120,23 +84,3 @@
     conducer.rb
     upload.rb
   ]
-
-
-  unless defined?(::UUIDTools::Config)
-    ::UUIDTools.module_eval do
-      Config = ::RbConfig # shuts up warnings...
-    end
-  end
-
-# protect against rails' too clever reloading
-#
-=begin
-  if defined?(Rails)
-    unless defined?(unloadable)
-      require 'active_support'
-      require 'active_support/dependencies'
-    end
-    unloadable(Dao)
-  end
-  BEGIN{ Object.send(:remove_const, :Dao) if defined?(Dao) }
-=end