dry-view 0.1.1 → 0.2.0

data/spec/unit/scope_spec.rb

@@ -0,0 +1,98 @@
+require 'dry/view/scope'
+
+RSpec.describe Dry::View::Scope do
+  subject(:scope) {
+    described_class.new(renderer, data, context)
+  }
+
+  let(:renderer) { double("renderer") }
+  let(:data) { {} }
+  let(:context) { Object.new }
+
+  describe "missing method behavior" do
+    before do
+      allow(renderer).to receive(:lookup).and_return false
+      allow(renderer).to receive(:render)
+    end
+
+    describe "accessing data" do
+      let(:data) { {user_name: "Jane Doe", current_user: "data's current_user"} }
+      let(:context) {
+        Class.new do
+          def current_user
+            "context's current_user"
+          end
+        end.new
+      }
+
+      before do
+        allow(renderer).to receive(:lookup).with('_current_user').and_return '_current_user.html.slim'
+      end
+
+      it "returns matching scope data" do
+        expect(scope.user_name).to eq "Jane Doe"
+      end
+
+      it "raises an error when no data matches" do
+        expect { scope.missing }.to raise_error(NoMethodError)
+      end
+
+      it "returns data in favour of both context methods and partials" do
+        expect(scope.current_user).to eq "data's current_user"
+      end
+    end
+
+    describe "accessing context" do
+      let(:context) {
+        Class.new do
+          def current_user
+            "context's current_user"
+          end
+
+          def asset(name)
+            "#{name}.jpg"
+          end
+        end.new
+      }
+
+      before do
+        allow(renderer).to receive(:lookup).with('_current_user').and_return '_current_user.html.slim'
+      end
+
+      it "forwards to matching methods on the context in favour of partials" do
+        expect(scope.current_user).to eq "context's current_user"
+      end
+
+      it "allows arguments to be passed to those methods as normal" do
+        expect(scope.asset("mindblown")).to eq "mindblown.jpg"
+      end
+
+      it "raises an error when no method matches" do
+        expect { scope.missing }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "rendering" do
+      before do
+        allow(renderer).to receive(:lookup).with('_list').and_return '_list.html.slim'
+      end
+
+      it "renders a matching partial using the existing scope" do
+        scope.list
+
+        expect(renderer).to have_received(:render).with('_list.html.slim', scope)
+      end
+
+      it "renders a matching partial using a scope based on arguments passed" do
+        scope.list(something: 'else')
+
+        expect(renderer).to have_received(:render)
+          .with('_list.html.slim', described_class.new(renderer, something: 'else'))
+      end
+
+      it "raises an error if arguments passed are not a hash" do
+        expect { scope.list('hi') }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

metadata

@@ -1,29 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: dry-view
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Piotr Solnica
+- Tim Riley
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2016-07-07 00:00:00.000000000 Z
+date: 2017-01-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: inflecto
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -108,23 +95,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: capybara
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-description: Lightweight web application stack on top of Roda
+description: Functional view rendering system
 email:
 - piotr.solnica@gmail.com
+- tim@icelab.com.au
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -137,20 +111,25 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
-- benchmarks/templates/button.erb
+- benchmarks/templates/button.html.erb
 - benchmarks/view.rb
+- bin/console
 - dry-view.gemspec
 - lib/dry-view.rb
 - lib/dry/view.rb
-- lib/dry/view/layout.rb
-- lib/dry/view/null_part.rb
-- lib/dry/view/part.rb
+- lib/dry/view/controller.rb
+- lib/dry/view/exposure.rb
+- lib/dry/view/exposures.rb
+- lib/dry/view/path.rb
 - lib/dry/view/renderer.rb
-- lib/dry/view/value_part.rb
+- lib/dry/view/scope.rb
 - lib/dry/view/version.rb
+- spec/fixtures/templates/empty.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
 - spec/fixtures/templates/layouts/app.txt.erb
+- spec/fixtures/templates/parts_with_args.html.slim
+- spec/fixtures/templates/parts_with_args/_box.html.slim
 - spec/fixtures/templates/shared/_index_table.html.slim
 - spec/fixtures/templates/shared/_shared_hello.html.slim
 - spec/fixtures/templates/tasks.html.slim
@@ -159,12 +138,16 @@ files:
 - spec/fixtures/templates/users.txt.erb
 - spec/fixtures/templates/users/_row.html.slim
 - spec/fixtures/templates/users/_tbody.html.slim
+- spec/fixtures/templates/users_with_count.html.slim
+- spec/fixtures/templates_override/users.html.slim
+- spec/integration/exposures_spec.rb
 - spec/integration/view_spec.rb
 - spec/spec_helper.rb
-- spec/unit/layout_spec.rb
-- spec/unit/null_part_spec.rb
+- spec/unit/controller_spec.rb
+- spec/unit/exposure_spec.rb
+- spec/unit/exposures_spec.rb
 - spec/unit/renderer_spec.rb
-- spec/unit/value_part_spec.rb
+- spec/unit/scope_spec.rb
 homepage: https://github.com/dry-rb/dry-view
 licenses:
 - MIT
@@ -177,7 +160,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -185,14 +168,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: Lightweight web application stack on top of Roda
+summary: Functional view rendering system
 test_files:
+- spec/fixtures/templates/empty.html.slim
 - spec/fixtures/templates/hello.html.slim
 - spec/fixtures/templates/layouts/app.html.slim
 - spec/fixtures/templates/layouts/app.txt.erb
+- spec/fixtures/templates/parts_with_args.html.slim
+- spec/fixtures/templates/parts_with_args/_box.html.slim
 - spec/fixtures/templates/shared/_index_table.html.slim
 - spec/fixtures/templates/shared/_shared_hello.html.slim
 - spec/fixtures/templates/tasks.html.slim
@@ -201,9 +187,13 @@ test_files:
 - spec/fixtures/templates/users.txt.erb
 - spec/fixtures/templates/users/_row.html.slim
 - spec/fixtures/templates/users/_tbody.html.slim
+- spec/fixtures/templates/users_with_count.html.slim
+- spec/fixtures/templates_override/users.html.slim
+- spec/integration/exposures_spec.rb
 - spec/integration/view_spec.rb
 - spec/spec_helper.rb
-- spec/unit/layout_spec.rb
-- spec/unit/null_part_spec.rb
+- spec/unit/controller_spec.rb
+- spec/unit/exposure_spec.rb
+- spec/unit/exposures_spec.rb
 - spec/unit/renderer_spec.rb
-- spec/unit/value_part_spec.rb
+- spec/unit/scope_spec.rb

data/lib/dry/view/layout.rb

@@ -1,126 +0,0 @@
-require 'dry-configurable'
-require 'dry-equalizer'
-require 'inflecto'
-
-require 'dry/view/part'
-require 'dry/view/value_part'
-require 'dry/view/null_part'
-require 'dry/view/renderer'
-
-module Dry
-  module View
-    class Layout
-      include Dry::Equalizer(:config)
-
-      DEFAULT_DIR = 'layouts'.freeze
-
-      extend Dry::Configurable
-
-      setting :root
-      setting :name
-      setting :template
-      setting :formats, { html: :erb }
-      setting :scope
-
-      attr_reader :config, :scope, :layout_dir, :layout_path, :template_path,
-        :default_format
-
-      def self.renderer(format = default_format)
-        unless config.formats.key?(format.to_sym)
-          raise ArgumentError, "format +#{format}+ is not configured"
-        end
-
-        renderers[format]
-      end
-
-      def self.renderers
-        @renderers ||= Hash.new do |h, key|
-          h[key.to_sym] = Renderer.new(
-            config.root, format: key, engine: config.formats[key.to_sym]
-          )
-        end
-      end
-
-      def self.default_format
-        config.formats.keys.first
-      end
-
-      def initialize
-        @config = self.class.config
-        @default_format = self.class.default_format
-        @layout_dir = DEFAULT_DIR
-        @layout_path = "#{layout_dir}/#{config.name}"
-        @template_path = config.template
-        @scope = config.scope
-      end
-
-      def call(options = {})
-        renderer = self.class.renderer(options.fetch(:format, default_format))
-
-        template_content = renderer.(template_path, template_scope(options, renderer))
-
-        renderer.(layout_path, layout_scope(options, renderer)) do
-          template_content
-        end
-      end
-
-      def locals(options)
-        options.fetch(:locals, {})
-      end
-
-      def parts(locals, renderer)
-        return empty_part(template_path, renderer) unless locals.any?
-
-        part_hash = locals.each_with_object({}) do |(key, value), result|
-          part =
-            case value
-            when Array
-              el_key = Inflecto.singularize(key).to_sym
-
-              template_part(
-                key, renderer,
-                value.map { |element| template_part(el_key, renderer, element) }
-              )
-            else
-              template_part(key, renderer, value)
-            end
-
-          result[key] = part
-        end
-
-        part(template_path, renderer, part_hash)
-      end
-
-      private
-
-      def layout_scope(options, renderer)
-        part_hash = {
-          page: layout_part(:page, renderer, options.fetch(:scope, scope))
-        }
-
-        part(layout_dir, renderer, part_hash)
-      end
-
-      def template_scope(options, renderer)
-        parts(locals(options), renderer)
-      end
-
-      def layout_part(name, renderer, value)
-        part(layout_dir, renderer, { name => value })
-      end
-
-      def template_part(name, renderer, value)
-        part(template_path, renderer, { name => value })
-      end
-
-      def part(dir, renderer, value = {})
-        part_class = value.values[0] ? ValuePart : NullPart
-        part_class.new(renderer.chdir(dir), value)
-      end
-
-      def empty_part(dir, renderer)
-        Part.new(renderer.chdir(dir))
-      end
-    end
-  end
-end

data/lib/dry/view/null_part.rb

@@ -1,30 +0,0 @@
-require 'dry-equalizer'
-require 'dry/view/value_part'
-
-module Dry
-  module View
-    class NullPart < ValuePart
-      def [](key)
-      end
-
-      def each(&block)
-      end
-
-      def respond_to_missing?(*)
-        true
-      end
-
-      private
-
-      def method_missing(meth, *args, &block)
-        template_path = template?("#{meth}_missing")
-
-        if template_path
-          render(template_path)
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/dry/view/part.rb

@@ -1,39 +0,0 @@
-require 'dry-equalizer'
-
-module Dry
-  module View
-    class Part
-      include Dry::Equalizer(:renderer)
-
-      attr_reader :renderer
-
-      def initialize(renderer)
-        @renderer = renderer
-      end
-
-      def render(path, &block)
-        renderer.render(path, self, &block)
-      end
-
-      def template?(name)
-        renderer.lookup("_#{name}")
-      end
-
-      def respond_to_missing?(meth, include_private = false)
-        super || template?(meth)
-      end
-
-      private
-
-      def method_missing(meth, *args, &block)
-        template_path = template?(meth)
-
-        if template_path
-          render(template_path, &block)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/dry/view/value_part.rb

@@ -1,50 +0,0 @@
-require 'dry-equalizer'
-require 'dry/view/part'
-
-module Dry
-  module View
-    class ValuePart < Part
-      include Dry::Equalizer(:renderer, :_data, :_value)
-
-      attr_reader :_data, :_value
-
-      def initialize(renderer, data)
-        super(renderer)
-        @_data = data
-        @_value = data.values[0]
-      end
-
-      def to_s
-        _value.to_s
-      end
-
-      def [](key)
-        _value[key]
-      end
-
-      def each(&block)
-        _value.each(&block)
-      end
-
-      def respond_to_missing?(meth, include_private = false)
-        _data.key?(meth) || super
-      end
-
-      private
-
-      def method_missing(meth, *args, &block)
-        template_path = template?(meth)
-
-        if template_path
-          render(template_path, &block)
-        elsif _data.key?(meth)
-          _data[meth]
-        elsif _value.respond_to?(meth)
-          _value.public_send(meth, *args, &block)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/spec/unit/layout_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe Dry::View::Layout do
-  subject(:layout) { layout_class.new }
-
-  let(:layout_class) do
-    klass = Class.new(Dry::View::Layout)
-
-    klass.configure do |config|
-      config.root = SPEC_ROOT.join('fixtures/templates')
-      config.name = 'app'
-      config.template = 'user'
-      config.formats = {html: :slim}
-    end
-
-    klass
-  end
-
-  let(:page) do
-    double(:page, title: 'Test')
-  end
-
-  let(:options) do
-    { scope: page, locals: { user: { name: 'Jane' }, header: { title: 'User' } } }
-  end
-
-  let(:renderer) do
-    layout.class.renderers[:html]
-  end
-
-  describe '#call' do
-    it 'renders template within the layout' do
-      expect(layout.(options)).to eql(
-        '<!DOCTYPE html><html><head><title>Test</title></head><body><h1>User</h1><p>Jane</p></body></html>'
-      )
-    end
-  end
-
-  describe '#parts' do
-    it 'returns view parts' do
-      part = layout.parts({ user: { id: 1, name: 'Jane' } }, renderer)
-
-      expect(part[:id]).to be(1)
-      expect(part[:name]).to eql('Jane')
-    end
-
-    it 'builds null parts for nil values' do
-      part = layout.parts({ user: nil }, renderer)
-
-      expect(part[:id]).to be_nil
-    end
-
-    it 'returns empty part when no locals are passed' do
-      expect(layout.parts({}, renderer)).to be_instance_of(Dry::View::Part)
-    end
-  end
-end

data/spec/unit/null_part_spec.rb

@@ -1,39 +0,0 @@
-require 'dry/view/null_part'
-
-RSpec.describe Dry::View::NullPart do
-  subject(:part) do
-    Dry::View::NullPart.new(renderer, data)
-  end
-
-  let(:name) { :user }
-  let(:data) { { user: nil } }
-
-  let(:renderer) { double(:renderer) }
-
-  describe '#[]' do
-    it 'returns nil for any data value names' do
-      expect(part[:email]).to eql(nil)
-    end
-  end
-
-  describe '#method_missing' do
-    it 'renders a template with the _missing suffix' do
-      expect(renderer).to receive(:lookup).with('_row_missing').and_return('_row_missing.slim')
-      expect(renderer).to receive(:render).with('_row_missing.slim', part)
-
-      part.row
-    end
-
-    it 'renders a _missing template within another when block is passed' do
-      block = proc { part.fields }
-
-      expect(renderer).to receive(:lookup).with('_form_missing').and_return('form_missing.slim')
-      expect(renderer).to receive(:lookup).with('_fields_missing').and_return('fields_missing.slim')
-
-      expect(renderer).to receive(:render).with('form_missing.slim', part, &block)
-      expect(renderer).to receive(:render).with('fields_missing.slim', part)
-
-      part.form(block)
-    end
-  end
-end

data/spec/unit/value_part_spec.rb

@@ -1,55 +0,0 @@
-require 'dry/view/part'
-
-RSpec.describe Dry::View::ValuePart do
-  subject(:part) do
-    Dry::View::ValuePart.new(renderer, data)
-  end
-
-  let(:name) { :user }
-  let(:data) { { user: { email: 'jane@doe.org' } } }
-
-  let(:renderer) { double(:renderer) }
-
-  describe '#[]' do
-    it 'gives access to data values' do
-      expect(part[:email]).to eql('jane@doe.org')
-    end
-  end
-
-  describe '#render' do
-    it 'renders given template' do
-      expect(renderer).to receive(:render).with('row.slim', part)
-
-      part.render('row.slim')
-    end
-  end
-
-  describe '#template?' do
-    it 'asks renderer if there is a valid template for a given identifier' do
-      expect(renderer).to receive(:lookup).with('_row').and_return('row.slim')
-
-      expect(part.template?('row')).to eql('row.slim')
-    end
-  end
-
-  describe '#method_missing' do
-    it 'renders template' do
-      expect(renderer).to receive(:lookup).with('_row').and_return('_row.slim')
-      expect(renderer).to receive(:render).with('_row.slim', part)
-
-      part.row
-    end
-
-    it 'renders template within another when block is passed' do
-      block = proc { part.fields }
-
-      expect(renderer).to receive(:lookup).with('_form').and_return('form.slim')
-      expect(renderer).to receive(:lookup).with('_fields').and_return('fields.slim')
-
-      expect(renderer).to receive(:render).with('form.slim', part, &block)
-      expect(renderer).to receive(:render).with('fields.slim', part)
-
-      part.form(block)
-    end
-  end
-end