sequent-sinatra 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a73084ee9f260f29469a257639ec887e5c7a537
-  data.tar.gz: 85aa9e6af284495f7d33f8153460b8c43d8c1b3f
+  metadata.gz: c6370a605d3032c7a3703e6b3d0ab82d4ac39f7c
+  data.tar.gz: 9d78a48b9878443e3b88b1c2f3b4f9b54acad5dc
 SHA512:
-  metadata.gz: bb42453351dffb2645e22763510c9833b535a0348b7d41d3894aa7d941ead955dfd5cdd3154c5d4412a28be88cf24c3e3c3e3baceaf495a23c312ed13d13c2ca
-  data.tar.gz: fe7c9d65de1bae9b9ae48ee604acdf83774b0e5e4b74faf7f4985e7e59ab931155dbe5875526dbd67351ec5a82dd3d055f2d6d5c89c68b1ec2f5ecfb5dde47d8
+  metadata.gz: 27aa83a9d1ed558bb83b046ceb4c6164bde37ea756bb980af508260dae753f69e5f61e96a2a1e0b847dd702f09977c57b5f08e89dfcf3241cffcf686508d8769
+  data.tar.gz: d46569e2c082c724ca22a55d28b35875d0efc3551257e071ca64ef75d1245ec3b55b72177d580b5173e258e0b58afa6a8f8e5807713b9f41ab315cbeec2946dc

data/lib/sequent-sinatra/app.rb

@@ -0,0 +1,35 @@
+require 'sinatra'
+module Sequent
+  module Web
+    module Sinatra
+      # Allows for easy integration with Sinatra apps.
+      # Provides:
+      #
+      #   +Sequent::Core::Helpers::UuidHelper+
+      #   +FormHelpers+
+      #   +SimpleCommandServiceHelpers+
+      #
+      # The +sequent_config_dir+ allows you to specify the directory containing the
+      # 'initializers/sequent' file that initializes the +EventStore+ and +CommandService+ for your webapp.
+      #
+      # class MySinatraApp < Sinatra::Base
+      #   set :sequent_config_dir, root
+      #   register Sequent::Web::Sinatra::App
+      # end
+      module App
+        def self.registered(app)
+          app.helpers Sequent::Core::Helpers::UuidHelper
+          app.helpers Sequent::Web::Sinatra::FormHelpers
+          app.helpers Sequent::Web::Sinatra::SimpleCommandServiceHelpers
+
+          app.before do
+            require File.join(app.sequent_config_dir || app.root, 'initializers/sequent')
+            @command_service = Sequent::Core::CommandService.instance
+          end
+
+        end
+      end
+    end
+  end
+end
+Sinatra.register Sequent::Web::Sinatra::App

data/lib/sequent-sinatra/fieldset.rb

@@ -0,0 +1,37 @@
+require_relative 'tag_helper'
+require_relative 'fieldset'
+
+module Sequent
+  module Web
+    module Sinatra
+      class Fieldset
+        include Sequent::Web::Sinatra::TagHelper
+
+        attr_reader :path, :parent
+
+        def initialize(parent, path, params, errors, options = {})
+          raise "params are empty while creating new fieldset path #{path}" unless params
+          @values = params.has_key?(path) ? (params[path] || {}) : {}
+          @parent = parent
+          @path = path.to_s.gsub(/\W+/, '')
+          @errors = errors
+          @options = options
+        end
+
+        def nested(name)
+          yield Fieldset.new(self, name, @values, @errors, @options)
+        end
+
+        def method_missing(method, *args, &block)
+          @parent.send(method, *args)
+        end
+
+        def path_for(field_name)
+          css_id @path, field_name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sequent-sinatra/form.rb

@@ -0,0 +1,77 @@
+require_relative 'tag_helper'
+require_relative 'fieldset'
+
+module Sequent
+  module Web
+    module Sinatra
+      class Form
+        include TagHelper
+
+        def initialize(context, for_object, action, method=:get, options = {})
+          @context = context
+          @values = params
+          @errors = @context.instance_variable_get("@errors")
+          @for_object = for_object
+          @action = action
+          @method = method
+          @options = options
+        end
+
+        def path_for(field_name)
+          css_id field_name
+        end
+
+        def method_missing(method, *args, &block)
+          @context.send(method, *args)
+        end
+
+        def render(&block)
+          method_input = ''
+          if @method.is_a? Symbol
+            case @method.to_s.downcase
+              when 'delete', 'update'
+                method_input = %Q(<input type="hidden" name="_method" value="#{@method}" />)
+                @method = :post
+              when 'create'
+                @method = :post
+            end
+          end
+
+          inner_html = capture_erb(self, &block)
+          out = tag(:form, nil, {:action => @action, :method => @method.to_s.upcase}.merge(@options)) + method_input + csrf_tag
+          out << inner_html
+          out << '</form>'
+          buf = @context.instance_variable_get("@_out_buf")
+          buf << out
+
+        end
+
+        def fieldset(obj_name, options = {}, &block)
+          raise ArgumentError, "Missing block to fieldset()" unless block_given?
+          raise "can not create a fieldset without a form backing object" unless @for_object
+          params.merge!(params.nil? ? {obj_name.to_s => @for_object.as_params} : params.merge({obj_name.to_s => @for_object.as_params}))
+          yield Fieldset.new(@context, obj_name, HashWithIndifferentAccess.new(params), @errors, options)
+        end
+
+
+        private
+        def capture_erb(*args, &block)
+          erb_with_output_buffer { block_given? && block.call(*args) }
+        end
+
+        def erb_with_output_buffer(buf = '')
+          old_buffer = @context.instance_variable_get("@_out_buf")
+          @context.instance_variable_set "@_out_buf", buf
+          yield
+          @context.instance_variable_get("@_out_buf")
+        ensure
+          @context.instance_variable_set "@_out_buf", old_buffer
+        end
+
+
+      end
+
+    end
+  end
+end
+

data/lib/sequent-sinatra/form_helpers.rb

@@ -0,0 +1,30 @@
+require_relative 'form'
+require 'rack/csrf'
+
+module Sequent
+  module Web
+    module Sinatra
+      module FormHelpers
+        def html_form(action, method=:get, options={}, &block)
+          html_form_for nil, action, method, options, &block
+        end
+
+        def html_form_for(for_object, action, method=:get, options={}, &block)
+          raise "Given object of class #{for_object.class} does not respond to :as_params. Are you including Sequent::Core::Helpers::ParamSupport?" if (for_object and !for_object.respond_to? :as_params)
+          form = Form.new(self, for_object, action, method, options.merge(role: "form"))
+          form.render(&block)
+        end
+
+        def h(text)
+          Rack::Utils.escape_html(text)
+        end
+
+        def csrf_tag
+          raise "You must enable sessions to use FormHelpers" unless env
+          Rack::Csrf.csrf_tag(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/sequent-sinatra/sequent-sinatra.rb

@@ -0,0 +1,6 @@
+require_relative 'form_helpers'
+require_relative 'tag_helper'
+require_relative 'fieldset'
+require_relative 'form'
+require_relative 'simple_command_service_helpers'
+require_relative 'app'

data/lib/sequent-sinatra/simple_command_service_helpers.rb

@@ -0,0 +1,23 @@
+module Sequent
+  module Web
+    module Sinatra
+      module SimpleCommandServiceHelpers
+        #
+        # execute a single command. Since it is default for most cases a CommandNotValid exception is handled in this method.
+        #
+        # Example usage:
+        #
+        #   post '/foo' do
+        #     @command = FooCommand.from_params(params)
+        #     execute_command(@command, :erb_name)
+        #   end
+        def execute_command(command)
+          @command_service.execute_commands(command)
+          yield if block_given?
+        rescue Sequent::Core::CommandNotValid => e
+          yield e.errors_with_command_prefix if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/sequent-sinatra/tag_helper.rb

@@ -0,0 +1,155 @@
+module Sequent
+  module Web
+    module Sinatra
+      module TagHelper
+        def raw_checkbox(field, options={})
+          id = css_id(@path, field)
+          value = param_or_default(field, options[:value]) || id
+          values = [value].compact
+          single_tag :input, options.merge(
+                             :type => "checkbox", :id => id,
+                             :name => calculate_name(field),
+                             :value => value, checked: (values.include?(@values[field.to_s])) ? "checked" : nil
+                           )
+        end
+
+        def raw_input(field, options={})
+          raw_field(field, "text", options)
+        end
+
+        def raw_password(field, options={})
+          raw_field(field, "password", options)
+        end
+
+        def raw_textarea(field, options={})
+          value = param_or_default(field, options[:value])
+
+          with_closing_tag :textarea, value, {rows: "3"}.merge(options.merge(
+                                                                 :id => css_id(@path, field),
+                                                                 :name => calculate_name(field)
+                                                               ))
+        end
+
+        def raw_hidden(field, options={})
+          raw_field(field, "hidden", options)
+        end
+
+        def raw_select(field, values, options={})
+          value = param_or_default(field, options[:value])
+          content = ""
+          Array(values).each do |val|
+            id, text = id_and_text_from_value(val)
+            option_values = {value: id}
+            option_values.merge!(selected: "selected") if (id == value)
+            option_values.merge!(disabled: "disabled") if options[:disable].try(:include?, id)
+            content << tag(:option, text, option_values)
+          end
+          tag :select, content, options.merge(:id => css_id(@path, field), :name => calculate_name(field))
+        end
+
+        def calculate_name(field)
+          reverse_names = tree_in_names(field)
+          "#{reverse_names.first}#{reverse_names[1..-1].map { |n| "[#{n}]" }.join}"
+        end
+
+        def full_path(field)
+          tree_in_names(field).join('_')
+        end
+
+        alias_method :calculate_id, :full_path
+
+        def tree_in_names(field)
+          if respond_to? :path
+            names = [field, path]
+            parent = @parent
+            while parent.is_a? Fieldset
+              names << parent.path
+              parent = parent.parent
+            end
+            names.reverse
+          else
+            [field]
+          end
+        end
+
+        def param_or_default(field, default)
+          @values.nil? ? default : @values.has_key?(field.to_s) ? @values[field.to_s] || default : default
+        end
+
+
+        def id_and_text_from_value(val)
+          if val.is_a? Array
+            [val[0], val[1]]
+          else
+            [val, val]
+          end
+        end
+
+        def css_id(*things)
+          things.compact.map { |t| t.to_s }.join('_').downcase.gsub(/\W/, '_')
+        end
+
+        def tag(name, content, options={})
+          "<#{name.to_s}" +
+            (options.length > 0 ? " #{hash_to_html_attrs(options)}" : '') +
+            (content.nil? ? '>' : ">#{content}</#{name}>")
+        end
+
+        def single_tag(name, options={})
+          "<#{name.to_s} #{hash_to_html_attrs(options)} />"
+        end
+
+        def with_closing_tag(name, value, options={})
+          %Q{<#{name.to_s} #{hash_to_html_attrs(options)} >#{h value}</#{name.to_s}>}
+        end
+
+        def hash_to_html_attrs(options={})
+          raise %Q{Keys used in options must be a Symbol. Don't use {"class" => "col-md-4"} but use {class: "col-md-4"}} if options.keys.find { |k| not k.kind_of? Symbol }
+          html_attrs = ""
+          options.keys.sort.each do |key|
+            next if options[key].nil? # do not include empty attributes
+            html_attrs << %Q(#{key}="#{h(options[key])}" )
+          end
+          html_attrs.chop
+        end
+
+        def merge_and_append_class_attributes(to_append, options = {})
+          to_append.merge(options) do |key, oldval, newval|
+            key == :class ? "#{oldval} #{newval}" : newval
+          end
+        end
+
+        def i18n_name(field)
+          if @path
+            "#{@path}.#{field}"
+          else
+            field.to_s
+          end
+        end
+
+        def has_form_error?(name)
+          @errors.try(:has_key?, name.to_sym)
+        end
+
+        private
+        def raw_field(field, field_type, options)
+          value = param_or_default(field, options[:value])
+          if options[:formatter]
+            value = self.send(options[:formatter], value)
+            options.delete(:formatter)
+          end
+          id = options[:id] || css_id(@path, field)
+          single_tag :input, options.merge(
+                             :type => field_type,
+                             :id => id,
+                             :name => calculate_name(field),
+                             :value => value
+                           )
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/version.rb

@@ -0,0 +1,3 @@
+module SequentSinatra
+  VERSION='0.1.1'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent-sinatra
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Lars Vonk
@@ -135,6 +135,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/sequent-sinatra.rb
+- lib/sequent-sinatra/app.rb
+- lib/sequent-sinatra/fieldset.rb
+- lib/sequent-sinatra/form.rb
+- lib/sequent-sinatra/form_helpers.rb
+- lib/sequent-sinatra/sequent-sinatra.rb
+- lib/sequent-sinatra/simple_command_service_helpers.rb
+- lib/sequent-sinatra/tag_helper.rb
+- lib/version.rb
 homepage: https://github.com/zilverline/sequent-sinatra
 licenses:
 - MIT