angular_sprinkles 0.0.1

data/lib/angular_sprinkles/helpers/bind_helper.rb

@@ -0,0 +1,55 @@
+require 'action_view/helpers'
+require 'angular_sprinkles/mixins/js_transformable'
+require 'angular_sprinkles/mixins/initializable'
+require 'angular_sprinkles/data/bind'
+
+module AngularSprinkles
+  module Helpers
+    module BindHelper
+      include ::ActionView::Helpers
+      include Mixins::JsTransformable
+      include Mixins::Initializable
+
+      def bind(*input)
+        input = input.flatten.compact
+
+        raise ArgumentError if input.empty?
+
+        yield_to_sprinkles(AngularSprinkles::CONSTRUCTOR_DEFINITION) unless app_initialized?
+
+        build_chain(input).
+          select(&method(:is_uninitialized?)).
+          map(&method(:convert_to_empty_js_object_string)).
+          tap(&method(:yield_if_any))
+
+        AngularSprinkles::Data::Bind.new(*input)
+      end
+
+      private
+
+      def build_chain(input)
+        # [:a, :b, :c, :d] => [[:a], [:a, :b], [:a, :b, :c]]
+        (1...input.count).inject([]) { |acc,i| acc << input.first(i) }
+      end
+
+      def is_uninitialized?(var)
+        !var_initialized?(var)
+      end
+
+      def convert_to_empty_js_object_string(var)
+        set_prototype_variable(var.join('.'), {})
+      end
+
+      def yield_if_any(chain)
+        yield_to_sprinkles(chain.join(";\n") + ';') if chain.any?
+      end
+
+      def yield_to_sprinkles(content)
+        content_for(:sprinkles) do
+          content_tag(:script, content.html_safe)
+        end
+      end
+
+    end
+  end
+end

data/lib/angular_sprinkles/helpers/directive_helper.rb

@@ -0,0 +1,30 @@
+require 'action_view/helpers'
+
+module AngularSprinkles
+  module Helpers
+    module DirectiveHelper
+      include ::ActionView::Helpers
+
+      def directive(name, input = {}, options = {}, &block)
+        raise TypeError unless [String, Symbol, Array].include?(name.class)
+        raise TypeError unless input.is_a?(Hash)
+        raise TypeError unless options.is_a?(Hash)
+
+        input.symbolize_keys!
+        options.symbolize_keys!
+
+        tag_contents = block_given? ? capture(&block) : ''
+        tag_attributes = {}
+        tag_name = options[:tag] || :div
+
+        directive_attributes = Hash[input.map { |k, v| [k, v.to_json] }]
+        name_attributes = Hash[[name].flatten.product([''])]
+
+        tag_attributes[:data] = [directive_attributes, name_attributes].compact.inject(&:merge)
+        tag_attributes.merge!(options.slice(:class, :style))
+
+        content_tag(tag_name, tag_contents, tag_attributes)
+      end
+    end
+  end
+end

data/lib/angular_sprinkles/helpers.rb

@@ -0,0 +1,9 @@
+require 'angular_sprinkles/helpers/bind_helper'
+require 'angular_sprinkles/helpers/directive_helper'
+
+module AngularSprinkles
+  module Helpers
+    include Helpers::BindHelper
+    include Helpers::DirectiveHelper
+  end
+end

data/lib/angular_sprinkles/mixins/initializable.rb

@@ -0,0 +1,20 @@
+module AngularSprinkles
+  module Mixins
+    module Initializable
+      def app_initialized?
+        @_sprinkles_app_initialized or (@_sprinkles_app_initialized = true) && false
+      end
+
+      def var_initialized?(variable)
+        variable = [variable].flatten
+        initialized_variables[variable] or (initialized_variables[variable] = true) && false
+      end
+
+      private
+
+      def initialized_variables
+        @_sprinkles_initialized_variables ||= {}
+      end
+    end
+  end
+end

data/lib/angular_sprinkles/mixins/js_transformable.rb

@@ -0,0 +1,23 @@
+module AngularSprinkles
+  module Mixins
+    module JsTransformable
+      def to_ctrl_variable(str)
+        "#{AngularSprinkles::CONTROLLER_NAME}.#{str}"
+      end
+
+      def set_prototype_variable(key, value)
+        or_equals_js(to_ctrl_prototype_variable(key), value)
+      end
+
+      private
+
+      def or_equals_js(key, value)
+        "#{key} = #{key} || #{value.to_json}";
+      end
+
+      def to_ctrl_prototype_variable(str)
+        "#{AngularSprinkles::CONTROLLER_FN}.prototype.#{str}"
+      end
+    end
+  end
+end

data/lib/angular_sprinkles/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+module AngularSprinkles
+  class Railtie < ::Rails::Railtie
+    initializer "angular_sprinkles.setup_view_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ::AngularSprinkles::Helpers
+      end
+    end
+  end
+end

data/lib/angular_sprinkles.rb

@@ -0,0 +1,13 @@
+module AngularSprinkles
+  PREFIX = 'sprinkles'
+  APP_NAME = "#{PREFIX}App"
+  CONTROLLER_NAME = "#{PREFIX}Ctrl"
+  CONTROLLER_FN = "window.#{CONTROLLER_NAME}Fn"
+  CONSTRUCTOR_DEFINITION = "#{CONTROLLER_FN} = #{CONTROLLER_FN} || function(){}"
+end
+
+require 'angular_sprinkles/helpers'
+require 'angular_sprinkles/decorators'
+require 'angular_sprinkles/controller'
+require 'angular_sprinkles/engine'
+require 'angular_sprinkles/railtie'

data/spec/controller_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Controller do
+  class StubController
+    include AngularSprinkles::Controller
+
+    def initialize(params)
+      @params = params
+    end
+
+    def index
+      assignable(@params)
+    end
+  end
+
+  let(:key) { 'key' }
+  let(:value) { 'value' }
+  let(:controller) { StubController.new(params) }
+
+  context 'when given a hash' do
+    context 'and it is not empty' do
+      let(:params) { { key => value } }
+
+      it 'preloads the input data' do
+        result = [
+          AngularSprinkles::CONSTRUCTOR_DEFINITION,
+          %{#{AngularSprinkles::CONTROLLER_FN}.prototype.#{key} = #{AngularSprinkles::CONTROLLER_FN}.prototype.#{key} || "#{value}"}
+        ]
+
+        expect(controller.index).to eq(result)
+      end
+    end
+
+    context 'and it is an empty hash' do
+      let(:params) { {} }
+
+      it 'only returns the prototype definition' do
+        result = [AngularSprinkles::CONSTRUCTOR_DEFINITION]
+        expect(controller.index).to eq(result)
+      end
+    end
+  end
+
+  context 'when given anything else' do
+    let(:params) { value }
+
+    it 'raises an exception' do
+      expect { controller.index }.to raise_error(TypeError)
+    end
+  end
+
+end

data/spec/data/bind_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Data::Bind do
+  let(:keys) { [:brewhouse, :software] }
+  let(:object) { AngularSprinkles::Data::Bind.new(*keys) }
+
+  it 'returns the concatenation of the two keys' do
+    expect(object.to_json).to eq("#{AngularSprinkles::CONTROLLER_NAME}.#{keys.join('.')}")
+    expect(object.to_s).to eq("#{AngularSprinkles::CONTROLLER_NAME}.#{keys.join('.')}")
+  end
+end

data/spec/decorators/bind_decorator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Decorators::Bind do
+  class StubObject
+    attr_reader :some_attr
+
+    def initialize(some_attr)
+      @some_attr = some_attr
+    end
+  end
+
+  class StubContext
+    def bind(*args)
+    end
+
+    def var_initialized?(*args)
+    end
+
+    def set_prototype_variable(*args)
+    end
+
+    def content_for(*args)
+    end
+  end
+
+  let(:context) { StubContext.new }
+  let(:context_proc) { ->{ context } }
+
+  let(:attr) { :brewhouse }
+  let(:key) { 'software' }
+  let(:object) { StubObject.new(attr) }
+
+  subject { AngularSprinkles::Decorators::Bind.new(object, key, context_proc) }
+
+  describe '#bind' do
+    context 'when no arguments are passed' do
+      it 'creates the necessary object binding' do
+        expect(context).to receive(:bind)
+        subject.bind
+      end
+    end
+
+    context 'when more than one argument is passed' do
+      it 'creates the necessary object binding' do
+        expect(context).to receive(:bind).with(key, nil)
+        subject.bind
+      end
+
+      it 'creates additional bindings' do
+        expect(context).to receive(:bind).with(key, :some_attr)
+        subject.bind(:some_attr)
+      end
+
+    end
+  end
+
+end

data/spec/helpers/bind_helper_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Helpers::BindHelper do
+  class StubClass
+    include AngularSprinkles::Helpers::BindHelper
+  end
+
+  let(:stub) { StubClass.new }
+
+  before { allow(stub).to receive(:content_for).and_return(true) }
+
+  context 'when 0 arguments' do
+    it 'raises an argument error' do
+      expect { stub.bind }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when 1 argument' do
+    let(:var) { :brewhouse }
+
+    it 'returns the variable name given as a js string' do
+      expect(stub.bind(var).to_json).
+        to(eq("#{AngularSprinkles::CONTROLLER_NAME}.#{var}"))
+    end
+
+    it 'only yields the constructor definition to the view' do
+      expect(stub).to receive(:yield_to_sprinkles).with(AngularSprinkles::CONSTRUCTOR_DEFINITION)
+      stub.bind(var)
+    end
+  end
+
+  context 'when 2 arguments' do
+    let(:vars) { [:brewhouse, :software] }
+
+    it 'returns the variables chained together as a js string' do
+      expect(stub.bind(*vars).to_json).
+        to(eq("#{AngularSprinkles::CONTROLLER_NAME}.#{vars.join('.')}"))
+    end
+
+    it 'yields the contructor definition and the first variable to the function to prototype' do
+      expect(stub).to receive(:yield_to_sprinkles).with(AngularSprinkles::CONSTRUCTOR_DEFINITION)
+      expect(stub).to receive(:yield_to_sprinkles).
+        with("#{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first} = #{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first} || {};")
+
+      stub.bind(*vars)
+    end
+  end
+
+  context 'when 3 arguments' do
+    let(:vars) { [:brewhouse, :software, :is_neat] }
+
+    it 'returns the variables chained together as a js string' do
+      expect(stub.bind(*vars).to_json).
+        to(eq("#{AngularSprinkles::CONTROLLER_NAME}.#{vars.join('.')}"))
+    end
+
+    it 'yields the constructor definition and the first variable to the function to prototype' do
+      expect(stub).to receive(:yield_to_sprinkles).with(AngularSprinkles::CONSTRUCTOR_DEFINITION)
+      expect(stub).to receive(:yield_to_sprinkles).
+        with(%{#{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first} = #{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first} || {};
+#{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first(2).join('.')} = #{AngularSprinkles::CONTROLLER_FN}.prototype.#{vars.first(2).join('.')} || {};})
+
+      stub.bind(*vars)
+    end
+  end
+
+  context 'when bind is called more than once' do
+    let(:vars) { [:brewhouse, :software, :is_neat] }
+
+    context 'and it is with the same variables' do
+      it 'yields the constructor definition and the first variable to the function to prototype' do
+        expect(stub).to receive(:content_for).twice
+        5.times { stub.bind(*vars) }
+      end
+    end
+
+    context 'and it is called with different sets of variables' do
+      it 'yields the constructor definition, first variable, and a chain of the first two variables' do
+        expect(stub).to receive(:content_for).exactly(3).times
+
+        stub.bind(vars.first) # yields the constructor
+        stub.bind(vars.first) # yields nothing
+        stub.bind(*vars.first(2)) # yields declaration for :brewhouse
+        stub.bind(*vars) # yields declaration for [:brewhouse, :software]
+        stub.bind(*vars) # yields nothing
+      end
+    end
+  end
+
+  context 'when the constructor has already been yielded' do
+    let(:var) { :brewhouse }
+
+    before { allow(stub).to receive(:app_initialized?).and_return(true) }
+
+    it 'does not yield anything with only one argument' do
+      expect(stub).not_to receive(:content_for)
+      stub.bind(var)
+    end
+  end
+
+end

data/spec/helpers/directive_helper_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Helpers::DirectiveHelper do
+  class StubClass
+    include AngularSprinkles::Helpers::DirectiveHelper
+  end
+
+  let(:stub) { StubClass.new }
+  let(:var) { 'brewhouse' }
+  let(:var2) { 'software' }
+  let(:var_binded) { AngularSprinkles::Data::Bind.new(var) }
+  let(:var2_binded) { AngularSprinkles::Data::Bind.new(var2) }
+
+  it 'renders a tag' do
+    html = stub.directive(:blink)
+
+    expect(html).to eq('<div data-blink=""></div>')
+  end
+
+  it 'renders a tag for multiple directives' do
+    html = stub.directive([:blink, :block])
+
+    expect(html).to eq('<div data-blink="" data-block=""></div>')
+  end
+
+  it 'renders a tag with initial values' do
+    html = stub.directive(:blink, { input: 42 })
+
+    expect(html).to eq('<div data-blink="" data-input="42"></div>')
+  end
+
+  it 'renders a tag with a binding as the initial value' do
+    html = stub.directive(:blink, { input: var_binded, some_other_input: [1,2,3] })
+
+    expect(html).
+      to eq(%{<div data-blink="" data-input="#{AngularSprinkles::CONTROLLER_NAME}.#{var}" data-some-other-input="[1,2,3]"></div>})
+  end
+
+  it 'renders a tag with a nested binding as the initial value' do
+    html = stub.directive(:blink, { input: var2_binded })
+
+    expect(html).
+      to eq(%{<div data-blink="" data-input="#{AngularSprinkles::CONTROLLER_NAME}.#{var2}"></div>})
+  end
+
+  it 'renders a tag with class and style' do
+    klass = 'brewhouse'
+    style = 'color:red;'
+
+    html = stub.directive(:blink, {}, { class: klass, style: style })
+
+    expect(html).to eq(%{<div class="#{klass}" data-blink="" style="#{style}"></div>})
+  end
+
+  it 'raises an exception if the name is not a string, symbol, or array' do
+    expect { stub.directive(Object.new) }.to raise_error(TypeError)
+    expect { stub.directive(1) }.to raise_error(TypeError)
+    expect { stub.directive({}) }.to raise_error(TypeError)
+  end
+
+  it 'raises an exception if the input and options are not hashes' do
+    expect { stub.directive(:blink, 1) }.to raise_error(TypeError)
+    expect { stub.directive(:blink, {}, :brewhouse) }.to raise_error(TypeError)
+  end
+
+end

data/spec/mixins/initializable_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Mixins::Initializable do
+  class StubClass
+    include AngularSprinkles::Mixins::Initializable
+  end
+
+  let(:stub_class) { StubClass.new }
+
+  describe '#app_initialized?' do
+    it 'returns false the first time and true after that' do
+      expect(stub_class.app_initialized?).to eq(false)
+      expect(stub_class.app_initialized?).to eq(true)
+      expect(stub_class.app_initialized?).to eq(true)
+    end
+  end
+
+  describe '#var_initialized?' do
+    it 'returns false the first time and true after that' do
+      var = 'a.b'
+
+      expect(stub_class.var_initialized?(var)).to eq(false)
+      expect(stub_class.var_initialized?(var)).to eq(true)
+      expect(stub_class.var_initialized?(var)).to eq(true)
+
+      expect(stub_class.var_initialized?(var + '.c')).to eq(false)
+      expect(stub_class.var_initialized?(var + '.c')).to eq(true)
+    end
+  end
+
+end

data/spec/mixins/js_transformable_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe AngularSprinkles::Mixins::JsTransformable do
+  class StubClass
+    include AngularSprinkles::Mixins::JsTransformable
+  end
+
+  let(:stub_class) { StubClass.new }
+
+  describe "#to_ctrl_variable" do
+    it 'returns a javascript variable string' do
+      str = 'brewhouse'
+
+      expect(stub_class.to_ctrl_variable(str)).
+        to(eq("#{AngularSprinkles::CONTROLLER_NAME}.#{str}"))
+    end
+  end
+
+  describe "#set_prototype_variable" do
+    it 'returns a javascript variable string with a preset value' do
+      key, value = 'brewhouse', 'software'
+
+      expect(stub_class.set_prototype_variable(key, value)).
+        to(eq("#{AngularSprinkles::CONTROLLER_FN}.prototype.#{key} = #{AngularSprinkles::CONTROLLER_FN}.prototype.#{key} || #{value.to_json}"))
+    end
+  end
+
+  # these methods moved to private
+
+  # describe "#to_ctrl_prototype_variable" do
+  #   it 'returns a javascript prototype variable string' do
+  #     str = 'brewhouse'
+
+  #     expect(stub_class.to_ctrl_prototype_variable(str)).
+  #       to(eq("#{AngularSprinkles::CONTROLLER_FN}.prototype.#{str}"))
+  #   end
+  # end
+
+  # describe "#or_equals_js" do
+  #   it 'returns a javascript variable string' do
+  #     expect(stub_class.or_equals_js('brewhouse', 'bacon')).
+  #       to(eq('brewhouse = brewhouse || "bacon"'))
+  #   end
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_profile 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rbenv/"
+end
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'rails'
+require 'angular_sprinkles'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end