access_schema 0.0.1 → 0.1.0

data/README.md

@@ -1,6 +1,8 @@
 # AccessSchema gem - ACL/plans for your app
 
-AccessSchema provides a tool to define ACL schema with simple DSL.
+AccessSchema provides decoupled from Rails and ORM agnostic tool
+to define ACL schemas with realy simple DSL.
+
 Inspired by [ya_acl](https://github.com/kaize/ya_acl)
 
 With a couple of aliases in DSL it enables you to deal with tariff plans. Plan and role, feature and privilege are synonyms.
@@ -9,21 +11,99 @@ With a couple of aliases in DSL it enables you to deal with tariff plans. Plan a
   gem install access_schema
 ```
 
-## An example of typical use
+## An example of use
+
+
+### Accessing from application code
+
+In Rails controllers we usualy have a current_user and we can
+add some default options in helpers:
 
 ```ruby
-  #somewhere.rb
+  #access_schema_helper.rb
 
-  acl.require! review, :edit
+  class AccessSchemaHelper
 
-  plan.allow? review, :add_photo
+    def plan
+      AccessSchema.schema(:plans).with_options({
+        :plan => Rails.development? && params[:debug_plan] || current_user.try(:plan) || :none
+      })
+    end
+
+    def acl
+      AccessSchema.schema(:acl).with_options({
+        :role => current_user.try(:role) || :none,
+        :user_id => current_user.try(:id)
+      })
+    end
+
+  end
 
+```
+
+So at may be used in controllers:
+
+```ruby
+  acl.require! review, :edit
   plan.require! review, :mark_featured
 
 ```
 
+Or views:
+
+```ruby
+  - if plan.allow? review, :add_photo
+    = render :partial => "add_photo"
+```
+
+
+On the ather side there are no any current_user accessible. In a Service Layer for
+example. So we have to pass extra options:
+
+
+```ruby
+  #./app/services/review_service.rb
+
+  class ReviewService < BaseSevice
+
+    def mark_featured(review_id, options)
+
+      review = Review.find(review_id)
+
+      acl = AccessSchema.schema(:acl).with_options(:role => options[:actor].roles)
+      acl.require! review, :mark_featured
+
+      plans = AccessSchema.schema(:plans).with_options(:plan => options[:actor].plan)
+      plans.require! review, :mark_featured
+
+      review.featured = true
+      review.save!
+
+    end
+
+    def update(review_id, attrs)
+
+      review = Review.find(review_id)
+
+      acl = AccessSchema.schema(:acl).with_options(:role => options[:actor].roles)
+      acl.require! review, :edit
+
+      plans = AccessSchema.schema(:plans).with_options(:plan => options[:actor].plan)
+      plans.require! review, :edit, :new_attrs => attrs
+
+      review.update_attributes(attrs)
+
+    end
+
+  end
+
+```
+
+### Definition
+
 ```ruby
   # config/plans.rb
+
   plans do
     plan :none
     plan :bulb
@@ -37,6 +117,10 @@ With a couple of aliases in DSL it enables you to deal with tariff plans. Plan a
       subject.photos_count < limit
     end
 
+    assert :attrs, [:new_attrs, :disallow] do
+      # check if any disallowed attributes are changing in subject with new_attrs
+    end
+
   end
 
   namespace "Review" do
@@ -49,6 +133,16 @@ With a couple of aliases in DSL it enables you to deal with tariff plans. Plan a
       assert :photo_limit, [:flower], :limit => 10
     end
 
+    # Important fields from plans aspect:
+    #   greeting
+    #   logo
+    #   site_url
+    #
+    feature :edit, [:bouquet] do
+      assert :attrs, [:bulb], :disallow => [:greeting, :logo, :site_url]
+      assert :attrs, [:flower], :disallow => [:site_url]
+    end
+
   end
 ```
 
@@ -76,27 +170,22 @@ With a couple of aliases in DSL it enables you to deal with tariff plans. Plan a
   end
 ```
 
+## Configuration
 
-```ruby
-  #access_schema_helper.rb
+Configured schema can be accessed with AccessSchema.schema(name)
+anywhere in app. Alternatively it can be assempled with ServiceLocator.
 
-  class AccessSchemaHelper
 
-    def plan
-      @plan ||= AccessSchema.build_file "config/plans.rb"
-      AccessSchema.with_options(@plan, {
-        :plan => Rails.development? && params[:debug_plan] || current_user.try(:plan) || :none
-      })
-    end
+```ruby
+  #config/initializers/access_schema.rb
 
-    def acl
-      @acl ||= AccessSchema.build_file "config/acl.rb"
-      AccessSchema.with_options(@acl, {
-        :role => current_user.try(:role) || :none,
-        :user_id => current_user.try(:id)
-      })
-    end
+  AccessSchema.configure do
+
+    schema :plans, AccessSchema.build_file('config/plans.rb')
+    schema :acl, AccessSchema.build_file('config/acl.rb')
 
   end
 
 ```
+
+

data/lib/access_schema/builders/config_builder.rb

@@ -0,0 +1,36 @@
+module AccessSchema
+  class ConfigBuilder
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def self.build(&block)
+      builder = new(Config.new)
+      builder.instance_eval(&block)
+      builder.config.freeze
+    end
+
+    def schema(name, schema)
+      if schema.is_a?(Hash)
+        schema = schema_from_options(schema)
+      end
+      @config.add_schema(name, schema)
+    end
+
+    private
+
+    def schema_from_options(options)
+
+      if options[:file]
+        AccessSchema.build_file(options[:file])
+      else
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/access_schema/builders/schema_builder.rb

@@ -4,13 +4,13 @@ module AccessSchema
     def self.build(&block)
       builder = new(Schema.new)
       builder.instance_eval(&block)
-      builder.schema.freeze
+      Proxy.new(builder.schema)
     end
 
     def self.build_file(filename)
       builder = new(Schema.new)
       builder.instance_eval(File.read(filename))
-      builder.schema.freeze
+      Proxy.new(builder.schema)
     end
 
     def roles(&block)

data/lib/access_schema/config.rb

@@ -0,0 +1,17 @@
+module AccessSchema
+  class Config
+
+    def initialize
+      @schemas = {}
+    end
+
+    def add_schema(name, schema)
+      @schemas[name] = schema
+    end
+
+    def schema(name)
+      @schemas[name]
+    end
+
+  end
+end

data/lib/access_schema/proxy.rb

@@ -1,14 +1,23 @@
 module AccessSchema
   class Proxy
 
-    def initialize(schema, options)
+    def initialize(schema, options = {})
       @schema = schema
       @options = options
     end
 
+    def roles
+      @schema.roles
+    end
+
+    def plans
+      @schema.plans
+    end
+
     def allow?(*args)
       namespace = args[0]
       feature = args[1]
+
       role, options = case args[2]
       when Symbol, String
         [args[2], args[3]]
@@ -23,5 +32,9 @@ module AccessSchema
       @schema.require!(*args)
     end
 
+    def with_options(options)
+      Proxy.new(@schema, options)
+    end
+
   end
 end

data/lib/access_schema/version.rb

@@ -1,3 +1,3 @@
 module AccessSchema
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/access_schema.rb

@@ -1,12 +1,15 @@
 require 'access_schema/version'
 require 'access_schema/exceptions'
 
+require 'access_schema/config'
 require 'access_schema/schema'
 require 'access_schema/assert'
 require 'access_schema/namespace'
 require 'access_schema/element'
 require 'access_schema/expectation'
 
+require 'access_schema/builders/config_builder'
+
 require 'access_schema/builders/basic_builder'
 require 'access_schema/builders/roles_builder'
 require 'access_schema/builders/asserts_builder'
@@ -26,8 +29,12 @@ module AccessSchema
     SchemaBuilder.build_file(*args)
   end
 
-  def self.with_options(schema, options)
-    Proxy.new(schema, options)
+  def self.configure(&block)
+    @config = ConfigBuilder.build(&block)
+  end
+
+  def self.schema(name)
+    @config.schema(name)
   end
 
 end

data/spec/access_schema_spec.rb

@@ -2,42 +2,20 @@ require 'spec_helper'
 
 describe AccessSchema do
 
-  describe "#build" do
+  describe ".build" do
     it "returns schema"
   end
 
-  describe "#build_file" do
+  describe ".build_file" do
     it "returns schema"
   end
 
-  describe "#with_options" do
-
-    before do
-      @schema = AccessSchema.build_file('spec/schema_example.rb')
-    end
-
-    it "takes schema and options" do
-      lambda {
-        AccessSchema.with_options(@schema, {:plan => :none})
-      }.should_not raise_error
-    end
-
-    it "returns schema" do
-      result = AccessSchema.with_options(@schema, {:plan => :none})
-      %w{allow? require!}.should be_all{|m| result.respond_to?(m)}
+  describe ".configure" do
+    it "passess given block to ConfigBuilder.build method" do
+      block = proc {}
+      AccessSchema::ConfigBuilder.should_receive(:build).with(&block)
+      AccessSchema.configure(&block)
     end
-
-    it "allows to not specify plan for schema calls" do
-      schema = AccessSchema.with_options(@schema, {:plan => :flower})
-      schema.allow?("Review", :mark_featured).should be_true
-    end
-
-    it "but it accepts plan too" do
-      schema = AccessSchema.with_options(@schema, {})
-      schema.allow?("Review", :mark_featured, :flower).should be_true
-      schema.allow?("Review", :mark_featured, :none).should be_false
-    end
-
   end
 
 end

data/spec/assess_schema/config_builder_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+
+describe AccessSchema::ConfigBuilder do
+
+  it "can define schemas directly from file" do
+
+    config = AccessSchema::ConfigBuilder.build do
+      schema :acl, :file => 'spec/schema_example.rb'
+    end
+
+    config.schema(:acl).plans.should_not be_nil
+  end
+
+end

data/spec/assess_schema/proxy_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe AccessSchema::Proxy do
+
+  before do
+    @proxy = AccessSchema::Proxy.new(AccessSchema.build_file('spec/schema_example.rb'))
+  end
+
+  it "responds to allow? and require!" do
+    %w{allow? require!}.should be_all{|m| @proxy.respond_to?(m)}
+  end
+
+  describe "#with_options" do
+
+    before do
+      @schema = @proxy.with_options(:plan => :flower)
+    end
+
+    it "allows to not specify plan for schema calls" do
+      @schema.allow?("Review", :mark_featured).should be_true
+    end
+
+    it "but it accepts plan too" do
+      @schema.allow?("Review", :mark_featured, :flower).should be_true
+      @schema.allow?("Review", :mark_featured, :none).should be_false
+    end
+
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: access_schema
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-27 00:00:00.000000000 Z
+date: 2012-02-29 00:00:00.000000000 Z
 dependencies: []
 description: AccessSchema is a tool for ACL or tariff plans schema definition and
   checks
@@ -31,10 +31,12 @@ files:
 - lib/access_schema/assert.rb
 - lib/access_schema/builders/asserts_builder.rb
 - lib/access_schema/builders/basic_builder.rb
+- lib/access_schema/builders/config_builder.rb
 - lib/access_schema/builders/element_builder.rb
 - lib/access_schema/builders/namespace_builder.rb
 - lib/access_schema/builders/roles_builder.rb
 - lib/access_schema/builders/schema_builder.rb
+- lib/access_schema/config.rb
 - lib/access_schema/element.rb
 - lib/access_schema/exceptions.rb
 - lib/access_schema/expectation.rb
@@ -43,6 +45,7 @@ files:
 - lib/access_schema/schema.rb
 - lib/access_schema/version.rb
 - spec/access_schema_spec.rb
+- spec/assess_schema/config_builder_spec.rb
 - spec/assess_schema/proxy_spec.rb
 - spec/assess_schema/schema_builder_spec.rb
 - spec/assess_schema/schema_spec.rb
@@ -74,6 +77,7 @@ specification_version: 3
 summary: AccessSchema is an ACL tool
 test_files:
 - spec/access_schema_spec.rb
+- spec/assess_schema/config_builder_spec.rb
 - spec/assess_schema/proxy_spec.rb
 - spec/assess_schema/schema_builder_spec.rb
 - spec/assess_schema/schema_spec.rb