dao 5.6.1 → 7.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aa44a9f2c9e686fe6b08cd45e8b0517d8d03e336
+  data.tar.gz: 2c0e7da32f04b45de57f87b961e6cf4fa4e65ab6
+SHA512:
+  metadata.gz: d20cdbe9a84bb0123364518b0f4dbad1520abc527f5422c15503454cdf6cbcf57ed24d8ddf87d9ac48e26ce1b695c823315562dafa6a3a573940448e49d66d74
+  data.tar.gz: a135cbbab52a6ac7f8632d77865a93bc4e38bac98526f4695ca55c1ab4e5c53212cf1598d0cc9caa61a90df538b313e8f2cae839ecb3ccb0fcc87ea02c11fc61

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

@@ -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)
@@ -62,8 +62,8 @@ end
 
 task :gemspec do
   ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
-  ignore_directories = ['pkg', 'notes']
-  ignore_files = ['test/log', 'a.rb']
+  ignore_directories = ['pkg']
+  ignore_files = ['test/log']
 
   shiteless = 
     lambda do |list|
@@ -73,9 +73,9 @@ task :gemspec do
         ignore_extensions.any?{|ext| ext === extension}
       end
       list.delete_if do |entry|
-        #next unless test(?d, entry)
-        path = File.expand_path(entry)
-        ignore_directories.any?{|dir| path =~ /^#{ Regexp.escape(File.expand_path(dir)) }/}
+        next unless test(?d, entry)
+        dirname = File.expand_path(entry)
+        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
       end
       list.delete_if do |entry|
         next unless test(?f, entry)

data/dao.gemspec

@@ -3,21 +3,20 @@
 
 Gem::Specification::new do |spec|
   spec.name = "dao"
-  spec.version = "5.6.1"
+  spec.version = "7.0.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "dao"
-  spec.description = "presenter, conducer, api, and better form objects for you rails' pleasure"
+  spec.description = "presenter, conductor, api, and better form objects for you rails' pleasure"
   spec.license = "same as ruby's"
 
   spec.files =
-["Gemfile",
- "Gemfile.lock",
- "README",
+["README.md",
  "Rakefile",
  "dao.gemspec",
  "lib",
  "lib/dao",
  "lib/dao.rb",
+ "lib/dao/_lib.rb",
  "lib/dao/active_record.rb",
  "lib/dao/api",
  "lib/dao/api.rb",
@@ -42,6 +41,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",
@@ -85,6 +85,14 @@ Gem::Specification::new do |spec|
  "lib/dao/validations/common.rb",
  "lib/dao/validations/instance.rb",
  "lib/dao/validations/validator.rb",
+ "notes",
+ "notes/ara.txt",
+ "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",
@@ -93,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 = []
@@ -106,25 +115,23 @@ Gem::Specification::new do |spec|
   spec.test_files = nil
 
   
-    spec.add_dependency(*["rails", " ~> 3.1"])
+    spec.add_dependency(*["rails", " ~> 5.2"])
   
-    spec.add_dependency(*["map", " >= 6.0.0"])
+    spec.add_dependency(*["map", " ~> 6.0"])
   
-    spec.add_dependency(*["fattr", " >= 2.2"])
+    spec.add_dependency(*["fattr", " ~> 2.2"])
   
-    spec.add_dependency(*["coerce", " >= 0.0.3"])
+    spec.add_dependency(*["coerce", " ~> 0.0"])
   
-    spec.add_dependency(*["tagz", " >= 9.9.2"])
+    spec.add_dependency(*["tagz", " ~> 9.9"])
   
-    spec.add_dependency(*["multi_json", " >= 1.0.3"])
+    spec.add_dependency(*["multi_json", " ~> 1.0"])
   
-    spec.add_dependency(*["uuidtools", " >= 2.1.2"])
+    spec.add_dependency(*["uuidtools", " ~> 2.1"])
   
-    spec.add_dependency(*["wrap", " >= 1.5.0"])
+    spec.add_dependency(*["wrap", " ~> 1.5"])
   
-    spec.add_dependency(*["rails_current", " >= 1.8.0"])
-  
-    spec.add_dependency(*["rails_errors2html", " >= 1.3.0"])
+    spec.add_dependency(*["rails_current", " ~> 2.0"])
   
 
   spec.extensions.push(*[])

data/lib/dao.rb

@@ -10,81 +10,37 @@
 
 # dao libs
 #
-  module Dao
-    Version = '5.6.1' unless defined?(Version)
+  require "map"
+  require "fattr"
+  require "coerce"
+  require "tagz"
+  require "multi_json"
+  require "uuidtools"
+  require "wrap"
+  require "rails_current"
 
-    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
-
-# gems
 #
-  begin
-    require 'rubygems'
-  rescue LoadError
-    nil
-  end
-
-  if defined?(gem)
-    Dao.dependencies.each do |lib, dependency|
-      gem(*dependency)
-      require(lib)
-    end
-  end
+  require_relative 'dao/_lib.rb'
 
+#
   %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.load %w[
     blankslate.rb
     instance_exec.rb
@@ -97,6 +53,7 @@
     name.rb
     status.rb
     path_map.rb
+    errors2html.rb
     errors.rb
     messages.rb
     form.rb
@@ -127,16 +84,3 @@
       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