model_subsets 0.0.1 → 0.0.4

data/lib/model_subsets.rb

@@ -2,148 +2,259 @@ require "model_subsets/version"
 
 module ModelSubsets
 
-    # Includes class methods
-    def self.included(base)
-      base.extend ModelSubsets::ClassMethods
-    end
+  extend ActiveSupport::Concern
 
-    # Provides current subset fieldset list
-    def fieldset
-      self.class.subset_fieldset(self.subset)
-    end
+  # Return current subset fieldsets list
+  #
+  # @return [ Array ]
+  #
+  # @since 0.0.2
+  def fieldsets
+    subset_content[:fieldsets] if valid_subset?
+  end
 
-    # Whether a field is included in subset fieldset
-    def has_field? field
-      fieldset.include? field
-    end
+  # Whether subset includes a fieldset
+  #
+  # @example Check if a user has fieldset :common
+  #   user.has_fieldset? :common
+  #
+  # @param [ Symbol ] name The fieldset name
+  #
+  # @return  [ Boolean ]
+  #
+  # @since 0.0.2
+  def has_fieldset? name
+    fieldsets.include?(name) if valid_subset?
+  end
 
-    # Whether subset has a fieldset
-    def has_fieldset? fieldset
-      return unless self.class.subsets.has_key? self.subset
-      self.class.subsets[self.subset][:fieldsets].include? fieldset
-    end
+  # Whether subset is included in a subsets scope
+  #
+  # @example Check if current subset is in :users subsets scope
+  #   person.in_subset_scope? :users
+  #
+  # @param [ Symbol ] name The subsets scope name
+  #
+  # @return [ Boolean ]
+  #
+  # @since 0.0.4
+  def in_subsets_scope? name
+    self.class.subsets_scope(name).include? subset.to_sym
+  end
+
+  # Returns current subset content
+  # An empty Hash is returned if subset is not defined
+  #
+  # @return [ Hash ]
+  #
+  # @since 0.0.2
+  def subset_content
+    self.class.subsets[subset.to_sym] if valid_subset? 
+  end
+
+  # Whether a subset fieldset includes a field
+  # It only checks if the field is included in current subset fieldsets, not if the field is a column in the model
+  #
+  # @example Check if a user uses field :name
+  #   user.has_field? :name
+  #
+  # @param [ Symbol ] name The field name
+  #
+  # @return [ Boolean ]
+  #
+  # @since 0.0.2
+  def subset_field? name
+    subset_fields.include?(name) if subset_fields
+  end
+
+  # Return current subset fields list
+  #
+  # @return [ Array ]
+  #
+  # @since 0.0.2
+  def subset_fields
+    self.class.subset_fields(subset.to_sym) if valid_subset?
+  end
 
-    def valid_subset?
-      return true if self.class.subsets.keys.include? self.subset
-      errors.add(:subset, :invalid) if self.respond_to? errors
-      return false
+  # Whether current subset id is defined
+  # 
+  # @example Use valid_subset? as a model validation
+  #   validate :valid_subset?
+  #
+  # @return [ Boolean ]
+  #
+  # @since 0.0.2
+  def valid_subset?
+    return true if self.class.subsets.keys.include?(subset.to_s.to_sym)
+    errors.add(:subset, :invalid) if respond_to?(:errors)
+    false
+  end
+
+  module ClassMethods
+
+    # Defines a fieldset
+    #
+    # @example Define fieldset :login including fields :username and :password
+    #   fieldset :login, :username, :password
+    #
+    # @param [ Symbol ] name  The fieldset name
+    # @param [ Array ]  *args Fields names
+    #
+    # @since 0.0.2
+    def fieldset name, *args
+      @fieldsets ||= {}
+      @fieldsets[name] = args
     end
+    
+    # Defines a subset
+    # If no fieldset is included, all defined fieldsets will be included by default
+    # If fieldsets are defined on an extended subset, parents fieldsets will be ignored
+    #
+    # @example Define subset :user, which is a person able to login
+    #   subset :user, extends: :person, with: :login, scopes: :users
+    #
+    # @param [ Symbol ] name    The subset name
+    # @param [ Hash ]   options The options to pass to the subset
+    #
+    # @option options [ Boolean ]       :template  Whether subset is a template (only used as an extend)
+    # @option options [ Symbol ]        :group     Subset group name
+    # @option options [ Symbol, Array ] :fieldsets Explicit fieldsets list. Overrides default list (all or herited)
+    # @option options [ Symbol, Array ] :scopes    The scopes in which subset will be included
+    # @option options [ Symbol, Array ] :extends   Parent subsets
+    # @option options [ Symbol, Array ] :with      Fieldsets to be added to herited fieldsets
+    # @option options [ Symbol, Array ] :only      Filters fieldsets to remove fielsets not being in this list
+    # @option options [ Symbol, Array ] :except    Filters fieldsets to remove fieldsets being in this list
+    #
+    # @since 0.0.2
+    def subset name, options = {}
+      @subsets        ||= {}
+      @subsets_scopes ||= {}
+
+      options[:fieldsets] = [options[:fieldsets]] unless options[:fieldsets].blank? || options[:fieldsets].is_a?(Array)
 
-    module ClassMethods
+      # Subset is an extension
+      if options[:extends]
 
-      def fieldset *args
-        fieldset = args.shift
-        raise "fieldset id must be a Symbol (#{fieldset.class} given)" unless fieldset.is_a? Symbol
-        raise "fieldset fields must be an Array (#{args.class} given)" unless args.is_a? Array
-        args.each do |field|
-          raise "field name must be an Symbol (#{field.class} given)" unless field.is_a? Symbol
+        # Force extends option to Array
+        options[:extends] = [options[:extends]] unless options[:extends].is_a?(Array)
+        options[:extends].each do |source_subset|
+          next unless @subsets.has_key? source_subset
+          source_options = @subsets[source_subset].clone
+          source_options.delete :template
+          options = source_options.merge options
         end
-        @fieldsets ||= {}
-        @fieldsets[fieldset] = args
-      end
 
-      # Provides subset fieldset list
-      def subset_fieldset subset
-        return unless subsets.has_key? subset
-        subset_fields = []
-        subsets[subset][:fieldsets].each do |fieldset|
-          fieldset       = @fieldsets[fieldset].is_a?(Array) ? @fieldsets[fieldset] : [@fieldsets[fieldset]]
-          subset_fields |= fieldset
+        # Handle additional fieldsets list
+        if options[:with]
+          options[:with] = [options[:with]] unless options[:with].is_a?(Array)
+          options[:fieldsets] |= options[:with]
         end
-        subset_fields.uniq
+
+      # Include all fieldsets by default
+      elsif options[:fieldsets].blank?
+        options[:fieldsets] = @fieldsets.keys
       end
 
-      def subset subset, options = {}
-        raise "subset id must be a Symbol (#{subset.class} given)" unless subset.is_a? Symbol
-        raise "subset options must be a Hash (#{options.class} given)" unless options.is_a? Hash
-        @subsets_config ||= {}
-        @subsets_config[subset] = options
+      # Handle inclusion list
+      if options[:only]
+        options[:only] = [options[:only]] unless options[:only].is_a?(Array)
+        options[:fieldsets] &= options[:only]
       end
 
-      # Provides subsets with builded extends & fieldsets
-      def subsets options = {}
-        @subsets_config ||= {}
-        raise "subsets config must ba a Hash (#{@subsets_config.class} given)" unless @subsets_config.is_a? Hash
-
-        # Cache builded subsets
-        return @subsets unless @subsets.blank? || options[:purge]
-
-        @subsets = {}
-
-        @subsets_config.each do |subset, options|
-          # Can't define same subset twice
-          raise "subset '#{subset} is already defined" if @subsets.has_key? subset
-
-          # Subset is an extension
-          if options[:extends]
-
-            # Force extends option to Array
-            options[:extends] = [options[:extends]] unless options[:extends].is_a? Array
-            options[:extends].each do |source_subset|
-              next unless @subsets.has_key? source_subset
-              source_options = @subsets[source_subset].clone
-              source_options.delete  :abstract
-              options = source_options.merge options
-            end
-
-            # Handle additional fieldsets list
-            if options[:with]
-              options[:with]       = [options[:with]] unless options[:with].is_a? Array
-              options[:fieldsets] |= options[:with]
-            end
-
-          else
-            # Include all fieldsets by default
-            options[:fieldsets] = @fieldsets.keys
-          end
-
-          # Handle inclusion list
-          if options[:only]
-            options[:only]       = [options[:only]] unless options[:only].is_a? Array
-            options[:fieldsets] &= options[:only]
-          end
-
-          # Handle exclusion list
-          if options[:except]
-            options[:except]     = [options[:except]] unless options[:except].is_a? Array
-            options[:fieldsets] -= options[:except]
-          end
-
-          # Cleanup
-          options[:fieldsets] = options[:fieldsets].uniq & @fieldsets.keys
-          remove_options      = [:extends, :with, :only, :except]
-          options             = options.clone
-          options.delete_if{ |key, value| remove_options.include?(key) }
-          @subsets[subset] = options
-        end
+      # Handle exclusion list
+      if options[:except]
+        options[:except] = [options[:except]] unless options[:except].is_a?(Array)
+        options[:fieldsets] -= options[:except]
+      end
 
-        @subsets = @subsets.reject{|key, value| value[:abstract] == true}
+      # Handle scopes
+      options[:scopes] ||= []
+      options[:scopes] = [options[:scopes]] unless options[:scopes].is_a?(Array)
+      options[:scopes].each do |subset_scope|
+        @subsets_scopes[subset_scope] ||= []
+        @subsets_scopes[subset_scope] << name unless options[:template]
+        scope subset_scope, where(:subset.in => @subsets_scopes[subset_scope])
       end
 
-      # Provides subsets groups list formatted for use with grouped collection select
-      def subsets_groups
-        groups     = {}
-        i18n_group = {}
+      # Cleanup
+      options[:fieldsets] = options[:fieldsets].uniq & @fieldsets.keys
+      remove_options      = [:extends, :with, :only, :except]
+      options             = options.clone
+      options.delete_if{ |key, value| remove_options.include?(key) }
 
-        subsets.each do |subset, options|
-          raise "subset id must be a Symbol (#{subset.class} given)" unless subset.is_a? Symbol
+      # Register subset
+      @subsets[name] = options
+    end
 
-          # Set default group
-          options[:group] = :default unless options[:group]
+    # Return subset fields list
+    #
+    # @example Get fields included in subset :user of model Person
+    #   Person.subset_fields :user
+    #   => [ :name, :givenname, :username, :password ]
+    #
+    # @params [ Symbol ] name The subset name
+    #
+    # @returns [ Array ]
+    #
+    # @since 0.0.1
+    def subset_fields name
+      return unless subsets.has_key?(name) && subsets[name].has_key?(:fieldsets)
+      subset_fields = []
+      subsets[name][:fieldsets].each do |fieldset|
+        fieldset = @fieldsets[fieldset].is_a?(Array) ? @fieldsets[fieldset] : [@fieldsets[fieldset]]
+        subset_fields |= fieldset
+      end
+      subset_fields.uniq
+    end
 
-          raise "group id must be a Symbol (#{options[:group].class} given)" unless options[:group].is_a? Symbol
+    # Return builded subsets
+    #
+    # @return [ Hash ]
+    #
+    # @since 0.0.1
+    def subsets
+      @subsets.reject{ |name, options| options[:template] }
+    end
 
-          i18n_subset                   = self.human_attribute_name("subsets.#{subset}")
-          i18n_group[options[:group]] ||= self.human_attribute_name("subsets.#{options[:group]}")
-          groups[i18n_group[options[:group]]] ||= [options[:group], {}]
-          groups[i18n_group[options[:group]]].last[i18n_subset] = subset
-        end
+    # Provides grouped subsets list, formatted for use with grouped collection select
+    # 
+    # @return [ Array ]
+    #
+    # @since 0.0.1
+    def subsets_groups
+      groups     = {}
+      i18n_group = {}
 
-        # Rearrange groups
-        groups = groups.sort
-        groups.map do |group|
-          [group.last.first, group.first, group.last.last.sort]
-        end
+      subsets.each do |subset, options|
+        options[:group] = :default unless options[:group]
+        i18n_subset                   = self.human_attribute_name("subsets.#{subset}")
+        i18n_group[options[:group]] ||= self.human_attribute_name("subsets.#{options[:group]}")
+        groups[i18n_group[options[:group]]] ||= [options[:group], {}]
+        groups[i18n_group[options[:group]]].last[i18n_subset] = subset
       end
+
+      # Rearrange groups
+      groups = groups.sort
+      groups.map do |group|
+        [group.last.first, group.first, group.last.last.sort]
+      end
+    end
+
+    # Return subsets included of a subsets scope
+    # 
+    # @return [ Array ]
+    #
+    # @since 0.0.2
+    def subsets_scope name
+      subsets_scopes[name]
+    end
+
+    # Return subsets scopes list
+    # 
+    # @return [ Array ]
+    #
+    # @since 0.0.2
+    def subsets_scopes
+      @subsets_scopes
     end
+  end
 end

data/lib/model_subsets/class_methods.rb

@@ -0,0 +1,130 @@
+module ModelSubsets
+  module ClassMethods
+
+    # Creates a fieldset
+    def fieldset *args
+      fieldset = args.shift
+      raise "fieldset id must be a Symbol (#{fieldset.class} given)" unless fieldset.is_a? Symbol
+      raise "fieldset fields must be an Array (#{args.class} given)" unless args.is_a? Array
+      args.each do |field|
+        raise "field name must be an Symbol (#{field.class} given)" unless field.is_a? Symbol
+      end
+      @fieldsets ||= {}
+      @fieldsets[fieldset] = args
+    end
+
+    # Creates a subset
+    def subset subset, options = {}
+      raise "subset id must be a Symbol (#{subset.class} given)" unless subset.is_a? Symbol
+      raise "subset options must be a Hash (#{options.class} given)" unless options.is_a? Hash
+      @subsets_config ||= {}
+      @subsets_config[subset] = options
+    end
+
+    # Provides subset fieldset list
+    def subset_fieldset subset
+      return unless subsets.has_key?(subset) && subsets[subset].has_key?(:fieldsets)
+      subset_fields = []
+      subsets[subset][:fieldsets].each do |fieldset|
+        fieldset       = @fieldsets[fieldset].is_a?(Array) ? @fieldsets[fieldset] : [@fieldsets[fieldset]]
+        subset_fields |= fieldset
+      end
+      subset_fields.uniq
+    end
+
+    # Provides subsets with builded extends & fieldsets
+    def subsets options = {}
+      @subsets_config ||= {}
+      raise "subsets config must ba a Hash (#{@subsets_config.class} given)" unless @subsets_config.is_a? Hash
+
+      # Cache builded subsets
+      return @subsets unless @subsets.blank? || options[:purge]
+
+      @subsets = {}
+      @scopes  = {}
+
+      @subsets_config.each do |subset, options|
+        # Can't define same subset twice
+        raise "subset '#{subset} is already defined" if @subsets.has_key? subset
+
+        # Subset is an extension
+        if options[:extends]
+
+          # Force extends option to Array
+          options[:extends] = [options[:extends]] unless options[:extends].is_a? Array
+          options[:extends].each do |source_subset|
+            next unless @subsets.has_key? source_subset
+            source_options = @subsets[source_subset].clone
+            source_options.delete  :abstract
+            options = source_options.merge options
+          end
+
+          # Handle additional fieldsets list
+          if options[:with]
+            options[:with]       = [options[:with]] unless options[:with].is_a? Array
+            options[:fieldsets] |= options[:with]
+          end
+
+        else
+          # Include all fieldsets by default
+          options[:fieldsets] = @fieldsets.keys unless options[:fieldsets].is_a? Array
+        end
+
+        # Handle inclusion list
+        if options[:only]
+          options[:only]       = [options[:only]] unless options[:only].is_a? Array
+          options[:fieldsets] &= options[:only]
+        end
+
+        # Handle exclusion list
+        if options[:except]
+          options[:except]     = [options[:except]] unless options[:except].is_a? Array
+          options[:fieldsets] -= options[:except]
+        end
+
+        # Handle scopes
+        options[:scopes] = [options[:scopes]] unless options[:scopes].is_a? Array
+        options[:scopes].each do |scope|
+          @scopes[scope] ||= []
+          @scopes[scope] << subset
+        end
+
+        # Cleanup
+        options[:fieldsets] = options[:fieldsets].uniq & @fieldsets.keys
+        remove_options      = [:extends, :with, :only, :except]
+        options             = options.clone
+        options.delete_if{ |key, value| remove_options.include?(key) }
+        @subsets[subset] = options
+      end
+
+      @subsets = @subsets.reject{|key, value| value[:abstract] == true}
+    end
+
+    # Provides subsets groups list formatted for use with grouped collection select
+    def subsets_groups
+      groups     = {}
+      i18n_group = {}
+
+      subsets.each do |subset, options|
+        raise "subset id must be a Symbol (#{subset.class} given)" unless subset.is_a? Symbol
+
+        # Set default group
+        options[:group] = :default unless options[:group]
+
+        raise "group id must be a Symbol (#{options[:group].class} given)" unless options[:group].is_a? Symbol
+
+        i18n_subset                   = self.human_attribute_name("subsets.#{subset}")
+        i18n_group[options[:group]] ||= self.human_attribute_name("subsets.#{options[:group]}")
+        groups[i18n_group[options[:group]]] ||= [options[:group], {}]
+        groups[i18n_group[options[:group]]].last[i18n_subset] = subset
+      end
+
+      # Rearrange groups
+      groups = groups.sort
+      groups.map do |group|
+        [group.last.first, group.first, group.last.last.sort]
+      end
+    end
+    
+  end
+end

data/lib/model_subsets/version.rb

@@ -1,3 +1,3 @@
 module ModelSubsets
-  VERSION = "0.0.1"
+  VERSION = "0.0.4"
 end

data/model_subsets.gemspec

@@ -14,4 +14,7 @@ Gem::Specification.new do |gem|
   gem.name          = "model_subsets"
   gem.require_paths = ["lib"]
   gem.version       = ModelSubsets::VERSION
+
+  gem.add_dependency("activemodel", ["~> 3.1"])
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: model_subsets
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
-dependencies: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: ModelSubsets provides ability to split a single model into fields and
   properties subsets
 email:
@@ -25,6 +41,7 @@ files:
 - README.md
 - Rakefile
 - lib/model_subsets.rb
+- lib/model_subsets/class_methods.rb
 - lib/model_subsets/version.rb
 - model_subsets.gemspec
 homepage: https://github.com/porecreat/model_subets