faalis 2.0.0.rc6 → 2.0.0

data/lib/faalis/generators/concerns/required.rb

@@ -1,18 +0,0 @@
-module Faalis
-  module Generators
-    module Concerns
-
-      # Adds `required` key to `fields`. Fields with this key as true will
-      # be non optional fields
-      module RequireFields
-
-        private
-
-        def required_fields
-          # Returnes an array contains name of all fields with require = true
-          fields_with('required', true).collect {|x| x['name']}
-        end
-      end
-    end
-  end
-end

data/lib/faalis/generators/concerns/resource_fields.rb

@@ -1,147 +0,0 @@
-require 'faalis/generators/fields/relation'
-
-module Faalis
-  module Generators
-    module Concerns
-      # This **concern** module is one of the most important **concerns** in
-      # dashboard scaffold system. This module adds `fields` key to json file
-      # which use for defining the resource fields. `fields` key is an array
-      # of objects which each object represent a field. Each field have following
-      # attributes:
-      #
-      # **name**: Name of field
-      #
-      # **type**: Type of field. some of the most important types are: `string`,
-      #         `integer`, `flout`, `belongs_to`, `has_many`, `in`, `datetime`.
-      #          For complete list of types take a look at
-      #          `app/assets/javascripts/faalis/dashboard/modules/fields/`
-      #
-      # **to**: This attribute is just for `in`, `has_many` and `belongs_to` field
-      #       types which define the resource that current resource have dependency
-      #       with. Bear in mind that `in` type uses `to` attrbute as an array of
-      #       possible value for field and will render as a combobox.
-      #
-      # **options**: An object of type related objects. For example a list of
-      #            current resource parents just like `parent` key.
-      #
-      # **bulk**: All fields with true as `bulk` value will be used in bulk editor.
-      #
-      # **tab**: ID of a Tab that this field should be appear on.
-      #
-      # **required**: Field will be non optional.
-      module ResourceFields
-
-        private
-
-        # An array of fields like
-        # [name, type]
-        def fields(fields_source = resource_data['fields'])
-          fields = []
-          relations = ['belongs_to', 'has_many']
-
-          if fields?
-            fields_source.each do |field|
-              name = field['name']
-              type = field['type']
-              to = field['to']
-              options = field['options'] || {}
-
-              type = Relation.new(type, to, options) if relations.include? type
-              fields << [name, type, to]
-            end
-          end
-          fields
-        end
-
-        # Return the value of `attr_name` of `field_name` in
-        # resource_data["fields"]
-        def attrs(field_name, attr_name)
-          if fields?
-            field = fields_with('name', field_name)[0]
-            return field[attr_name]
-          end
-          nil
-        end
-
-        def fields_hash
-          Hash[fields]
-        end
-
-        def grid_fields
-          fields_with("view_in_grid", true)
-        end
-
-        # Return an string to use as a function parameters each
-        # field appears as symbol
-        def fields_as_params(relations = false)
-          # FIXME: cyclomatic complexity is to high
-          result = ''
-          field_num = 0
-
-          fields.each do |name, type|
-            if relations
-              if ['belongs_to'].include? type
-                result += " :#{name}_id"
-              else
-                result += " :#{name}"
-              end
-
-              field_num += 1
-              result += ',' if field_num < fields.length
-
-            else
-              unless ['belongs_to', 'has_many'].include? type
-                result += " :#{name}"
-                field_num += 1
-                result += ',' if field_num < fields.length
-              end
-            end
-          end
-
-          if result
-            result = ",#{result}"
-            result = result[0..-2] if result[-1] == ','
-          end
-
-          result
-        end
-
-        def raw_fields_data
-          resource_data['fields'] || []
-        end
-
-        def fields_with(attr, value)
-          raw_fields_data.select do |f|
-            if f.include? attr
-              f[attr] == value ? true : false
-            else
-              false
-            end
-          end
-        end
-
-        def fields_with_attribute(attr)
-          field_list = raw_fields_data.select do |f|
-            f.include?(attr) ? true : false
-          end
-          field_list
-        end
-
-        def no_filter?
-          resource_data.include?('no_filter') &&  resource_data['no_filter']
-        end
-
-        def no_duplicate?
-          resource_data.include?('no_duplicate') &&  resource_data['no_duplicate']
-        end
-
-        def fields?
-          if resource_data.include? 'fields'
-            return true unless resource_data['fields'].nil?
-          end
-          false
-        end
-      end
-    end
-  end
-end

data/lib/faalis/generators/concerns/resource_name.rb

@@ -1,39 +0,0 @@
-module Faalis
-  module Generators
-    module Concerns
-      # Adds the `name` key to json file which specify the resource name.
-      module ResourceName
-
-        private
-
-        # Path to the resource
-        def resource_path
-          path_parts = resource_data["name"].split("/")
-          if path_parts.length > 1
-            return "#{path_parts(0..-2).join("/")}/#{path_parts[-1].underscore}"
-          end
-          resource_data["name"].underscore
-        end
-
-        # Url of resource
-        def resource_url
-          path_parts = resource_data["name"].split("/")
-          if path_parts.length > 1
-            return "#{path_parts(0..-2).join("/")}/#{path_parts[-1].pluralize.underscore}"
-          end
-          resource_data["name"].pluralize.underscore
-        end
-
-        # Camelized resource name. you can think of it as model name
-        def resource
-          path_parts = resource_data["name"].split("/")
-          if path_parts.length > 1
-            return path_parts[-1].camelize
-          end
-          resource_data["name"].camelize
-        end
-
-      end
-    end
-  end
-end

data/lib/faalis/generators/concerns/tabs.rb

@@ -1,56 +0,0 @@
-require 'set'
-
-module Faalis
-  module Generators
-    module Concerns
-      # Using this **concern** module user can specify an array of tab objects
-      # which each one has an `id` and `name` attribute. Tabs will be added to
-      # **new** view of resource. Also this concern will a `tab` key to field
-      # object. All the fields with same `id` as a tab will be grouped in that
-      # tab
-      module Tabs
-
-        private
-        # Process the user provided tabs
-        # return a Hash of tabs like
-        def tabs
-          tabbed_fields = Set.new
-
-          if resource_data.include? 'tabs'
-
-            tabs = resource_data['tabs']
-            result = {}
-            tabs.each do |tab|
-              name = tab['name']
-
-              fields_list = fields_with('tab', tab['id'])
-              fields_list.each { |f| tabbed_fields << f }
-
-              result[name] = fields_list
-            end
-            all_fields = Set.new resource_data['fields']
-
-            result.each do |k, v|
-              if v.empty?
-                diff = (all_fields ^ tabbed_fields).to_a
-                result[k] = diff
-              end
-            end
-            return result
-          else
-            {}
-          end
-        end
-
-        def tab_has_field?(tab_name, field_name)
-          it_does = tabs[tab_name].select { |f| f['name'] == field_name }
-          !it_does.empty?
-        end
-
-        def any_tabs?
-          resource_data.include? 'tabs'
-        end
-      end
-    end
-  end
-end

data/lib/faalis/generators/concerns/where.rb

@@ -1,44 +0,0 @@
-module Faalis
-  module Generators
-    module Concerns
-
-      # This module is dedicated to filter resource object based
-      # on a condition or query. For example if you want to filter
-      # a resource objects to those which belongs to current logged
-      # in user you can do like:
-      #
-      # ```javascript
-      # ...
-      # "where": {
-      #     "user": "current_user"
-      # }
-      # ...
-      # ```
-      #
-      # `where` value is an object which each key is a ruby model
-      # field name and its value is the actual value that you want
-      # to use to check the field against that.
-      module Where
-        private
-
-        def where_cond?
-          if resource_data.include? 'where'
-            return true unless resource_data['where'].empty?
-          end
-          false
-        end
-
-        # Return a hash of parameters to pass to where method
-        def where_conditions
-          if has_where_cond?
-            flat_array = resource_data['where'].map do |field, value|
-              [field.to_sym, value]
-            end
-            Hash[flat_array]
-          end
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/faalis/generators/dashboard_scaffold.rb

@@ -1,62 +0,0 @@
-require 'rails/generators'
-
-module Faalis
-  module Generators
-    # `DashboardScaffold` is the base class for all the dashboard
-    # scaffolds which make creating scaffold generators way more
-    # easier. But you can drive your own generator normally of caurse
-    class DashboardScaffold < Rails::Generators::Base
-
-      include ::ActionView::Helpers::TextHelper
-      include Faalis::Generators::Concerns::InputFile
-      include Faalis::Generators::Concerns::ResourceName
-      include Faalis::Generators::Concerns::ResourceFields
-      include Faalis::Generators::Concerns::Menu
-      include Faalis::Generators::Concerns::Dependency
-      include Faalis::Generators::Concerns::Bulk
-      include Faalis::Generators::Concerns::RequireFields
-      include Faalis::Generators::Concerns::Parent
-      include Faalis::Generators::Concerns::Child
-      include Faalis::Generators::Concerns::Angular
-      include Faalis::Generators::Concerns::Tabs
-      include Faalis::Generators::Concerns::Model
-      include Faalis::Generators::Concerns::AllowQueryOn
-      include Faalis::Generators::Concerns::Render
-      include Faalis::Generators::Concerns::Where
-      include Faalis::Generators::Concerns::Fieldset
-
-      # Do not install specs
-      class_option :without_specs, type: :boolean, default: false, desc: 'Do not install specs'
-
-      # Generate only spec files
-      class_option :only_specs, type: :boolean, default: false, desc: 'Generate only spec files'
-
-      # TODO: Move it to listview generator
-      # Generate only controller
-      class_option :only_controller, type: :boolean, default: false, desc: 'Generate only controller'
-
-      # Don't show a filter box
-      class_option :no_filter, type: :boolean, default: false, desc: 'Don\'t view a filter box'
-
-
-      private
-
-      # Overrided `source_paths` method. With this approach extensions
-      # can override generators templates. Cool ha ?
-      def source_paths
-        @source_paths = self.class.source_paths_for_search
-
-        paths = []
-        Faalis::Extension.extensions.each do |name, klass|
-          if klass.respond_to? :generator_templates_path.to_sym
-            paths << klass.generator_templates_path
-          end
-        end
-        paths += @source_paths
-        @source_paths = paths
-      end
-
-
-    end
-  end
-end

data/lib/faalis/generators/fields/relation.rb

@@ -1,61 +0,0 @@
-module Faalis
-  module Generators
-    class Relation < String
-      attr_accessor :to
-
-      def initialize(value, to, options = "")
-        super(value)
-        @options = options
-        @to = to
-      end
-
-      def resource_name
-        to.split("/").last
-      end
-
-      def to
-        result = ""
-        if options.include? "parents"
-          field_parents.each do |parent|
-            result = "#{result}/#{parent}/' + $scope.#{parent}_id + '"
-          end
-          result = "#{result}/"
-        end
-        "#{result}#{@to}"
-      end
-
-      def options
-        unless @options.empty?
-          @options
-        else
-          {}
-        end
-      end
-
-      def field_parents
-        if options.include? "parents"
-          options["parents"]
-        else
-          []
-        end
-      end
-
-      def restangular
-        result = "API"
-        if options.include? "parents"
-          field_parents.each do |parent|
-            result = "#{result}.one('#{parent}', #{}_id)"
-          end
-        end
-        to.split("/").each do |resource|
-          result = "#{result}.all(\"#{resource}\")"
-        end
-        result
-      end
-
-      def get_list
-        "#{restangular}.getList()"
-      end
-    end
-  end
-end