x-editable-rails-bs4 1.5.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7b318db8e6922984c3d7e2fca3438daa69a11fe6e85e43d471c7122d70b46999
+  data.tar.gz: 6811a0a6d5ad9f7e28a98ff9657d5a9f1bb96fd6eae7c868fc9ab82cf6197c93
+SHA512:
+  metadata.gz: 36b4a011c954489a18817aafaca557a590a43c07c56a07d061f3e6600ea7665e82a4f4bcc71fabf4c3a2175ff7acf93f05e980a166e8aedc60a4624cdd8c6351
+  data.tar.gz: 4e194461803bb0550dfc4ee39f7b9fb352aeda8cb67390a6a9fa11922f73721714b2d0037f9e5794bc7a1c28c19de75b5f58ee51baa26fcd1aa7fb61d349ca81

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jiri Kolarik
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+# X::Editable::Rails
+
+[![Build Status](https://travis-ci.org/werein/x-editable-rails.svg)](https://travis-ci.org/werein/x-editable-rails)  [![Code Climate](https://codeclimate.com/github/werein/x-editable-rails/badges/gpa.svg)](https://codeclimate.com/github/werein/x-editable-rails) [![Test coverage](https://codeclimate.com/github/werein/x-editable-rails/badges/coverage.svg)](https://codeclimate.com/github/werein/x-editable-rails) [![Version](https://badge.fury.io/rb/x-editable-rails.svg)](https://badge.fury.io/rb/x-editable-rails) [![Dependencies](https://gemnasium.com/werein/x-editable-rails.svg)](https://gemnasium.com/werein/x-editable-rails)
+
+X-editable for Rails
+
+## Live demo
+
+Checkout live demo [here](https://x-editable-rails.herokuapp.com/?denied=true) 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'x-editable-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install x-editable-rails
+
+## Usage
+
+### Assets
+
+Choose between the following javascripts:
+
+* bootstrap-editable
+* bootstrap2-editable
+* jqueryui-editable
+* jquery-editable-poshytip
+
+You'll also need to include editable/rails in your scripts for this to work.
+
+```coffee
+#= require editable/bootstrap-editable
+#= require editable/rails
+```
+
+Choose the corresponding stylesheets:
+
+* bootstrap-editable
+* bootstrap2-editable
+* jqueryui-editable
+* jquery-editable
+
+```scss
+// as CSS
+*= require editable/bootstrap-editable
+
+// or SCSS
+@import "editable/bootstrap-editable";
+```
+
+Enable editing with jQuery:
+
+```coffee
+$('.editable').editable()
+```
+
+For custom inputs like the Wysihtml5 editor, add these dependencies:
+
+```coffee
+#= require editable/bootstrap-editable
+#= require editable/inputs-ext/wysihtml5
+#= require editable/inputs-ext/bootstrap-wysihtml5
+#= require editable/inputs-ext/wysihtml5-editable
+#= require editable/rails
+```
+
+And related stylesheets:
+
+```css
+//= require editable/bootstrap-editable
+//= require editable/inputs-ext/bootstrap-wysihtml5
+//= require editable/inputs-ext/wysiwyg-color
+```
+
+### Making Things Editable
+
+`x-editable-rails` provides a helper method in your view to make your model values editable.
+By default, you need to specify the model and property that should be editable.
+A `span` element is rendered with `data-*` attributes used by `x-editable`.
+
+```ruby
+# the editable object and the attribute to edit
+%h1= editable @model, :name
+```
+
+You can customize the tag name and title attribute:
+
+* **tag** - `span` by default.
+* **title** - The model and attribute name are used to create a capitalized title
+
+The `editable` helper method automatically adds these `data-*` attributes used by [x-editable](http://vitalets.github.io/x-editable/docs.html).
+
+* **url** - Uses the `polymorphic_path(model)` helper method.
+* **source** - Only populated if the value is a boolean to convert `true` or `false` to "Yes" and "No".
+* **value** - Uses `model.name`. If `model.name` were a boolean value or if a `source` is specified, the `source` text would be displayed rather than the raw value. (Presumably the value is an ID and the source would have the text associated with that value.)
+* **placeholder** - Uses the `title` value by default
+
+```ruby
+# editable object, what_you_want_update, e: exception - when is xeditable? false or can? :edit, object is false
+%h1= editable @model, :name, url: model_path, value: @model.name.upcase
+```
+
+Here are some special features to enhance what's baked into [x-editable](http://vitalets.github.io/x-editable/docs.html):
+
+* **type** - The type of input is automatically detected. By default, if the value is a boolean, the `type` is "select" with a built-in `source` that outputs "Yes" and "No" (unless another `source` is specified).
+* **source** - In addition to hashes or arrays of hashes, you can also use an array of strings for a simpler structure if the name and value are the same:
+
+```ruby
+source = [ "Active", "Disabled" ]
+editable @model, :enabled, source: source
+```
+
+* **value** - This option will override the `model.name` value
+* **classes** - This is a custom option for `x-editable-rails` that will change the editable element's CSS class based on the selected value. Use the `source` hash structure to map a CSS class name to a value. (This [functionality](vendor/assets/javascripts/editable/rails/data_classes.js.coffee) is toggled when the value changes and the "save" event is triggered.)
+
+```ruby
+source  = [ "Active", "Disabled" ]
+classes = { "Active" => "label-success", "Disabled" => "label-default" }
+editable @model, :enabled, source: source, classes: classes, class: "label"
+```
+
+* **nested** - Name of a nested attributes (such as [globalize](https://github.com/globalize/globalize)'s `translations`)
+* **nid** - ID of the nested attribute
+
+```ruby
+%h1= editable @model, :name, nested: :translations, nid: @model.translation.id
+
+# example of nested resource
+%h1= editable [picture.gallery, picture], :name, nested: :translations, nid: picture.translation.id
+```
+
+### Authorization
+
+Add a helper method to your controllers to indicate if `x-editable` should be enabled.
+
+```ruby
+def xeditable? object = nil
+  true # Or something like current_user.xeditable?
+end
+```
+
+You can use [CanCan](https://github.com/ryanb/cancan) and checks the `:edit` permission for the model being edited.
+
+```ruby
+def xeditable? object = nil
+  can?(:edit, object) ? true : false
+end
+```
+
+* **e** - Specify a custom (error) message to display if the value isn't editable
+
+### "Don't Repeat Yourself" Templates
+
+To make your views cleaner, you can specify all your options for each class and attribute in a YAML configuration file.
+Attributes where the `title` or `placeholder` are not different except maybe capitalized can be left out because they are automatically capitalized when rendered (see above).
+
+This example uses the `MailingList` class and its attributes.
+The attribute value can be a string, which is used as the `title` and `placeholder`.
+If you want to specify other options, create a hash of options.
+
+Install configuration file like this: `rails g x_editable_rails:install`, this step is not necessary
+
+```yaml
+class_options:
+  MailingList:
+    # Specify placeholder text for each attribute or a Hash of options
+    name: Mailing list name
+    enabled:
+      type: select
+      source:
+        - Active
+        - Disabled
+    reply_email:
+      type: email
+      title: Reply-to email
+  User:
+    email:
+      type: email
+    password:
+      type: password
+    mailing_lists:
+      type: select
+      # specify a URL to get source via AJAX (see x-editable docs)
+      source: <%= ::Rails.application.routes.url_helpers.mailing_lists_source_path %>
+```
+
+Now you can specify your editable fields without options because they will be inherited from your YAML config.
+
+```ruby
+model = MailingList.new
+
+editable model, :name    # type: "text",   title: "Mailing list name"
+editable model, :enabled # type: "select", title: "Enabled", source: [ "Active", "Disabled" ]
+```
+
+### Examples
+
+Gem also contains demo application with integrated x-editable
+
+```
+cd test/dummy
+rake db:migrate
+rake db:seed
+rails g x_editable_rails:install # optional, it generate config example
+rails s
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/generators/x_editable_rails/install_generator.rb

@@ -0,0 +1,12 @@
+module XEditableRails
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      desc 'Copy example of x-editable config'
+      def copy_x_editable_yml
+        template 'x-editable.yml', 'config/x-editable.yml'
+      end   
+    end
+  end
+end

data/lib/generators/x_editable_rails/templates/x-editable.yml

@@ -0,0 +1,19 @@
+# More informations you can find here: https://github.com/werein/x-editable-rails
+class_options:
+  MailingList:
+    name: Mailing list name
+    enabled:
+      type: select
+      source:
+        - Active
+        - Disabled
+    reply_email:
+      type: email
+      title: Reply-to email
+  User:
+    email:
+      type: email
+    password:
+      type: password
+    mailing_lists:
+      type: select

data/lib/x-editable-rails.rb

@@ -0,0 +1,15 @@
+require 'x-editable-rails/version'
+require 'x-editable-rails/configuration'
+require 'x-editable-rails/view_helpers'
+
+module X
+  module Editable
+    module Rails
+      class Engine < ::Rails::Engine
+        initializer 'x-editable-rails.view_helpers' do
+          ActionView::Base.send :include, ViewHelpers
+        end
+      end
+    end
+  end
+end

data/lib/x-editable-rails/configuration.rb

@@ -0,0 +1,62 @@
+module X
+  module Editable
+    module Rails
+      module Configuration
+        
+        def method_options_for(object, method)
+          class_options_for(object).fetch(method, {})
+        end
+        
+        def class_options_for(object)
+          class_options = options.fetch(:class_options, {})
+          class_options.fetch(object.class.name, {})
+        end
+        
+        def class_options
+          options.fetch(:class_options, {})
+        end
+        
+        def options
+          config_fn = ::Rails.root.join("config", "x-editable.yml")
+          if File.file?(config_fn)
+            @options ||= begin
+              options = load_yaml_file config_fn
+              format_class_options! options
+            end
+          else
+            @options = {}
+          end
+        end
+        
+        def load_yaml_file(path)
+          source = File.read path
+          source = ERB.new(source).result
+          
+          result = YAML.load(source)
+          result = {} if result.blank?
+          
+          result.with_indifferent_access
+        end
+        
+        private
+        
+        # if the specified options are a string, convert to Hash and make the string the title
+        def format_class_options!(options)
+          if class_options = options[:class_options]
+            class_options.each do |class_name, methods|
+              methods.each do |method, method_options|
+                unless method_options.is_a? Hash
+                  methods[method] = { title: method_options }.with_indifferent_access
+                end
+              end
+            end
+          end
+          
+          options
+        end
+        
+        extend self
+      end
+    end
+  end
+end

data/lib/x-editable-rails/version.rb

@@ -0,0 +1,7 @@
+module X
+  module Editable
+    module Rails
+      VERSION = "1.5.5.2"
+    end
+  end
+end

data/lib/x-editable-rails/view_helpers.rb

@@ -0,0 +1,167 @@
+require 'base64'
+
+module X
+  module Editable
+    module Rails
+      module ViewHelpers
+        #
+        # Options determine how the HTML tag is rendered and the remaining options are converted to data-* attributes.
+        #
+        # options:
+        #   tag:   tag name of element returned
+        #   class: "class" attribute on element
+        #   placeholder: "placeholder" attribute on element
+        #   title: "title" attribute on element (defaults to placeholder)
+        #   data:  "data-*" attributes on element
+        #     source: a Hash of friendly display values used by input elements based on (object) value
+        #       - boolean shorthand ['Enabled', 'Disabled'] becomes { '1' => 'Enabled', '0' => 'Disabled' }
+        #       - enumerable shorthand ['Yes', 'No', 'Maybe'] becomes { 'Yes' => 'Yes', 'No' => 'No', 'Maybe' => 'Maybe' }
+        #     classes: a Hash of classes to add based on the value (same format and shorthands as source)
+        #   value: override the object's value
+        #
+        def editable(object, method, options = {})
+          options = Configuration.method_options_for(object, method).deep_merge(options).with_indifferent_access
+          # merge data attributes for backwards-compatibility
+          options.merge! options.delete(:data){ Hash.new }
+
+          url     = options.delete(:url){ polymorphic_path(object) }
+          object  = object.last if object.kind_of?(Array)
+          value   = options.delete(:value){ object.send(method) }
+          source  = options[:source] ? format_source(options.delete(:source), value) : default_source_for(value)
+          classes = format_source(options.delete(:classes), value)
+          error   = options.delete(:e)
+          html_options = options.delete(:html){ Hash.new }
+
+          if xeditable?(object)
+            model   = object.class.model_name.param_key
+            nid     = options.delete(:nid)
+            nested  = options.delete(:nested)
+            title   = options.delete(:title) do
+              klass = nested ? object.class.const_get(nested.to_s.classify) : object.class
+              klass.human_attribute_name(method)
+            end
+
+            output_value = output_value_for(value)
+            css_list = options.delete(:class).to_s.split(/\s+/).unshift('editable')
+            css_list << classes[output_value] if classes
+            type = options.delete(:type){ default_type_for(value) }
+            css   = css_list.compact.uniq.join(' ')
+            tag   = options.delete(:tag){ 'span' }
+            placeholder = options.delete(:placeholder){ title }
+
+            # any remaining options become data attributes
+            data  = {
+              type:   type,
+              model:  model,
+              name:   method,
+              value:  ( type == 'wysihtml5' ? Base64.encode64(output_value) : output_value ), 
+              placeholder: placeholder,
+              classes: classes,
+              source: source,
+              url:    url,
+              nested: nested,
+              nid:    nid
+            }.merge(options.symbolize_keys)
+
+            data.reject!{|_, value| value.nil?}
+
+            html_options.update({
+              class: css,
+              title: title,
+              data: data
+            })
+
+            content_tag tag, html_options do
+              if %w(select checklist).include?(data[:type].to_s) && !source.is_a?(String)
+                source = normalize_source(source)
+                content = source.detect { |t| output_value == output_value_for(t[0]) }
+                content.present? ? content[1] : ""
+              else
+                safe_join(source_values_for(value, source), tag(:br))
+              end
+            end
+          else
+            error || safe_join(source_values_for(value, source), tag(:br))
+          end
+        end
+
+        private
+
+        def normalize_source(source)
+          return [] unless source
+          source.map do |el|
+            if el.is_a? Array
+              el
+            else
+              [el[:value], el[:text]]
+            end
+          end
+        end
+
+        def output_value_for(value)
+          value = case value
+          when TrueClass
+            '1'
+          when FalseClass
+            '0'
+          when NilClass
+            ''
+          when Array
+            value.map{|item| output_value_for item}.join(',')
+          else
+            value.to_s
+          end
+
+          value
+        end
+
+        def source_values_for(value, source = nil)
+          source ||= default_source_for value
+
+          values = Array.wrap(value)
+
+          if source && ( source.first.is_a?(String) || source.kind_of?(Hash) )
+            values.map{|item| source[output_value_for item]}
+          else
+            values
+          end
+        end
+
+        def default_type_for(value)
+          case value
+          when TrueClass, FalseClass
+            'select'
+          when Array
+            'checklist'
+          else
+            'text'
+          end
+        end
+
+        def default_source_for(value)
+          case value
+          when TrueClass, FalseClass
+            { '1' => 'Yes', '0' => 'No' }
+          end
+        end
+
+        # helper method that take some shorthand source definitions and reformats them
+        def format_source(source, value)
+          formatted_source = case value
+            when TrueClass, FalseClass
+              if source.is_a?(Array) && source.first.is_a?(String) && source.size == 2
+                { '1' => source[0], '0' => source[1] }
+              end
+            else
+              if source.is_a?(Array) && source.first.is_a?(String)
+                source.map { |v| { value: v, text: v } }
+              end
+            end
+
+          formatted_source || source
+        end
+
+      end
+    end
+  end
+end