opal-shimmer 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af6a671a4a06532b0934e407682744bdbef4da6f
+  data.tar.gz: 919e18ae911f83b2e07794b649d5d4b44bb81461
+SHA512:
+  metadata.gz: b831db064daa0baf27102cb59bda9796b3f5d5f3046f6766c57956f7f888747b2b42243cc6363b1a0547ebcb35069249a8733cb938af62705a2ff6952d7a63d6
+  data.tar.gz: 9958ef8839dcb23deb1880ded1c0e4dc023d8462b1d192eb3708207b04ca02e4f011a540415131c10723b7eb8cb8b317c95ba1b3215faf10f3c6a56fec64b003

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.2@ruby2rails4

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opal-shimmer.gemspec
+gemspec
+
+gem 'opal-rspec'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2015 Jared White
+
+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,82 @@
+# Opal: Shimmer
+
+Shimmer is an application state and configuration management library built with [Opal](http://opalrb.org), a Ruby-to-JS compiler.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'opal-shimmer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opal-shimmer
+
+## Usage
+
+Shimmer is very easy to use right out of the box. I'm assuming you'll be using it within the context of a Rails application for this tutorial. Make sure you add `//= require shimmer` to your application.js manifest file.
+
+    # Set up the config object:
+    config = Shimmer::Config.new
+    
+    # Set some values:
+    config.somevalue = "Wow"
+    config.othervalue = ['This', 'is', 'great!']
+    
+    # Get some values:
+    puts config.somevalue  # > "Wow"
+    
+    # Use namespaces to define very specific values:
+    config.several.levels.deep.stringvalue = "Your string here"
+    puts config.several.levels.deep.stringvalue  # > "Your string here"
+    
+    # Check whether a value exists:
+    puts config.foo.nil?
+    
+    # Set stuff in a namespace using a block:
+    config.really.deep.namespace do |c|
+      c.value1 = 1
+      c.value2 = 2
+    end
+    
+    # Persist values across sessions using localStorage:
+    config.persist(:cease_and_persist)
+    config.cease_and_persist = "abc123"
+    
+    config2 = Shimmer::Config.new  # this loads up a brand new object
+    config2.persist(:cease_and_persist)
+    
+    puts config2.cease_and_persist  # > "abc123"  Aha! it works!
+    
+    # An easier way to persist values by setting initial defaults
+    # and not overwriting values that get set differently later:
+    config.persist_defaults do |c|
+      c.somevalue = "abc"
+      c.othervalue = 123
+    end
+
+    # ...user triggers some action...
+    config.somevalue = "xyz"
+    
+    # ...days later on a subsquent browser session...
+    puts config.somevalue  # > "xyz"  not "abc" - Yay!
+    
+For more examples, look at the `config_spec.rb` and `storage_spec.rb` files in the `spec` folder.
+
+## Contributing
+
+1. Fork it ( http://github.com/jaredcwhite/opal-shimmer/fork )
+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
+
+## Testing
+
+Simply run `rackup` at your command line when you're in the project folder. It will load a webserver at port 9292. Then just go to your browser and access `http://localhost:9292`. You should get the full rspec suite runner output. (And hopefully, everything's green!)
+
+_If you have trouble using Safari, try using Chrome instead. I'm not sure why this is sometimes an issue..._

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/config.ru

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler.require
+
+run Opal::Server.new { |s|
+  s.main = 'opal/rspec/sprockets_runner'
+  s.append_path 'spec'
+  s.debug = false
+}

data/lib/opal-shimmer.rb

@@ -0,0 +1 @@
+require 'opal/shimmer'

data/lib/opal/shimmer.rb

@@ -0,0 +1,5 @@
+require 'opal'
+require 'opal/shimmer/version'
+
+# Just register our opal code path with opal build tools
+Opal.append_path File.expand_path('../../../opal', __FILE__)

data/lib/opal/shimmer/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module Shimmer
+    VERSION = "0.1.1"
+  end
+end

data/opal-shimmer.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opal/shimmer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opal-shimmer"
+  spec.version       = Opal::Shimmer::VERSION
+  spec.authors       = ["Jared White"]
+  spec.email         = ["jared@ealchemylabs.com"]
+  spec.description   = %q{An application state and configuration management library built with Opal}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/jaredcwhite/opal-shimmer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+	spec.add_dependency 'opal', '~> 0.7.0.beta1'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'opal-rspec', '~> 0.4.0.beta2'
+end

data/opal/shimmer.rb

@@ -0,0 +1,4 @@
+require 'set'
+require 'json'
+require 'shimmer/storage'
+require 'shimmer/config'

data/opal/shimmer/config.rb

@@ -0,0 +1,127 @@
+module Shimmer
+
+	class Config
+	  DEFAULT_CONFIG_PATH = "config"
+	
+	  def initialize(parent_key=nil, parent_level=nil)
+	    @parent_key = parent_key
+	    @parent_level = parent_level
+	    @store = {}
+	    @persisted_storage = Shimmer::Storage.new(self)
+	    @in_persisting_block = false
+	  end
+	  
+	  def parent_level
+	    @parent_level
+	  end
+	  def parent_key
+	    @parent_key || self.class::DEFAULT_CONFIG_PATH
+	  end
+	
+	  def method_missing(input_method_name, *args, &block)
+      method_name = input_method_name.to_s
+
+	    if method_name[-1] == "="
+	      save_key = method_name[0..-2]
+	      if @in_persisting_block
+  	      unless @persisted_storage.should_include?(save_key)
+	          @persisted_storage.should_include(save_key)
+	        end
+	        unless @persisted_storage.include?(save_key)
+	          @persisted_storage.save_value(save_key, args[0])
+	        end
+	      elsif !@in_persisting_block and @persisted_storage.should_include?(save_key)
+	        @store[save_key] = args[0]
+	        @persisted_storage.save_value(save_key, args[0])
+	      else
+	        @store[save_key] = args[0]
+	      end
+	    else
+	      if include?(method_name)
+	      	yield @store[method_name] if block
+	        @store[method_name]
+	      elsif @persisted_storage.should_include?(method_name)
+	        @store[method_name] = @persisted_storage.load_value(method_name)
+	        yield @store[method_name] if block
+	        @store[method_name]
+	      else
+	        new_config = self.class.new(method_name, self)
+	        yield new_config if block
+	        @store[method_name] = new_config
+	      end
+	    end
+	  end
+	  
+	  def persist(*keys)
+	    keys = [keys] unless keys.is_a?(Array)
+	    keys.each do |key|
+	      @persisted_storage.should_include(key)
+	    end
+	  end
+	  
+	  def persist_defaults(&block)
+	    @in_persisting_block = true
+	    yield self
+	    @in_persisting_block = false
+	  end
+	  
+	  def generate_key_path
+	    if @parent_level
+        path_segments = [@parent_key]
+        reached_top = false
+        current_level = @parent_level
+      
+        until reached_top
+          if current_level and current_level.parent_key
+            path_segments << current_level.parent_key
+            current_level = current_level.parent_level
+          else
+            reached_top = true
+          end
+        end
+        
+        path_segments.reverse.join(".")
+      elsif @parent_key
+        @parent_key
+      else
+        self.class::DEFAULT_CONFIG_PATH
+	    end
+	  end
+	  
+	  def include?(key)
+	    @store.include?(key)
+	  end
+	  
+	  def delete(key)
+	    if @persisted_storage.should_include?(key)
+	      @persisted_storage.delete_value(key)
+	    end
+	    @store.delete(key)
+	  end
+	  
+	  def nil?
+	    @store.length == 0
+	  end
+	  
+	  def to_s
+	    if @store.length == 0
+	      ""
+	    else
+	      @store.inspect
+	    end
+	  end
+	  
+	  def to_i
+	    0
+	  end
+	  
+	  def to_bool
+	    false
+	  end
+	  
+	  def to_h
+	    @store
+	  end
+	end
+	
+end

data/opal/shimmer/storage.rb

@@ -0,0 +1,38 @@
+module Shimmer
+	class Storage
+	  def initialize(config_object)
+	    @config_object = config_object
+	    @storage_path = config_object.generate_key_path
+	    @include_keys = Set.new
+	  end
+	  
+	  def load_value(key)
+	    json_value = `window.localStorage[#{@storage_path + '.' + key}]`
+	    if `json_value != null`
+  	    JSON.parse(json_value)
+  	  else
+  	    nil
+  	  end
+	  end
+	
+	  def save_value(key, value)
+	    `window.localStorage[#{@storage_path + '.' + key}] = #{JSON.dump(value)}`
+	  end
+	  
+	  def should_include?(key)
+	    @include_keys.include?(key)
+	  end
+	  def should_include(key)
+	    @include_keys << key
+	  end
+	  
+	  def include?(key)
+	    `window.localStorage[#{@storage_path + '.' + key}] != null`
+	  end
+	  
+	  def delete_value(key)
+	    @include_keys.delete(key)
+	    `window.localStorage.removeItem(#{@storage_path + '.' + key})`
+	  end
+	end
+end

data/spec/config_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe "Shimmer::Config" do
+  let(:config) { config = Shimmer::Config.new }
+
+  it "can set a single value" do
+    config.somevalue = "Wow"
+    
+    expect(config.somevalue).to eq("Wow")
+  end
+  
+  it "can set a namespaced valued" do
+    config.namespace.coolvalue = "Way awesome!"
+    
+    expect(config.namespace.coolvalue).to eq("Way awesome!")  
+  end
+  
+  it "can check nil when something doesn't exist" do
+    expect(config.foo.nil?).to eq(true)
+  end
+  
+  it "can call to_s on a blank value to get a blank string" do
+    expect(config.nothing.elsewill.matter.to_s).to eq("")
+  end
+  
+  it "can call to_i on a blank value to get 0" do
+    expect(config.supah.cool.to_i).to eq(0)
+  end
+
+  it "can call to_bool on a blank value to get false" do
+    expect(config.golden.gate.to_bool).to eq(false)
+  end
+  
+  it "can get a string printout of options" do
+    config.namespace.firstvalue = "abc"
+    config.namespace.secondvalue = 123
+    
+    expect(config.namespace.to_s).to eq("{\"firstvalue\"=>\"abc\", \"secondvalue\"=>123}")
+  end
+  
+  it "can get an options hash" do
+    config.namespace.firstvalue = "abc"
+    config.namespace.secondvalue = 123
+
+    expect(config.namespace.to_h).to be_a(Hash)
+  end
+  
+  it "can set a previous value to nil" do
+    config.avalue = [0,5,10]
+    config.avalue = nil
+    
+    expect(config.avalue.nil?).to eq(true)
+  end
+  
+  it "can check for existance of a value" do
+    expect(config.include?(:avalue)).to eq(false)
+    config.avalue = [0,5,10]
+    expect(config.include?(:avalue)).to eq(true)
+    expect(config.some.nested.include?(:avalue)).to eq(false)
+    config.some.nested.avalue = {:foo => "bar"}
+    expect(config.some.nested.include?(:avalue)).to eq(true)
+    expect(config.some.include?(:nested)).to eq(true)
+    expect(config.some.include?(:bested)).to eq(false)
+  end
+  
+  it "supports a block / tap style setting" do
+    config.really.deep.namespace do |c|
+      c.value1 = 1
+      c.value2 = 2
+    end
+    expect(config.really.deep.namespace.value2).to eq(2)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'shimmer'

data/spec/storage_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe "Shimmer::Storage" do
+  let(:config) { config = Shimmer::Config.new }
+  
+  it "generates correct paths" do
+    config.somevalue = "Wow"
+    expect(config.generate_key_path).to eq("config")
+    
+    config.several.levels.deep.lurks = "a monster!"
+    expect(config.several.levels.deep.generate_key_path).to eq("config.several.levels.deep")
+    
+    config2 = Shimmer::Config.new(:config2)
+    config2.properly.namespaces.itself = "which is cool"
+    expect(config2.properly.namespaces.generate_key_path).to eq("config2.properly.namespaces")
+  end
+  
+  it "persists a value" do
+    config.persist(:cease_and_persist)
+    config.cease_and_persist = "abc123"
+    
+    config2 = Shimmer::Config.new
+    config2.persist(:cease_and_persist)
+    expect(config2.cease_and_persist).to eq("abc123")
+  end
+  
+  it "works with complex values" do
+    config.persist(:somebool, :somearray, :somehash)
+    
+    config.somebool = true
+    config.somearray = [3, 9, "a", false]
+    config.somehash = {foo: "bar", baz: [3, 9]}
+    
+    config2 = Shimmer::Config.new
+    config2.persist(:somebool, :somearray, :somehash)
+
+    expect(config2.somebool).to eq(true)
+    expect(config2.somearray).to eq([3, 9, "a", false])
+    expect(config2.somehash).to eq({foo: "bar", baz: [3, 9]})
+  end
+  
+  it "works with namespaces" do
+    config.namespaced.persist(:avalue)
+    config.namespaced do |spaced|
+      spaced.avalue = "Groovy!"
+    end
+    
+    config2 = Shimmer::Config.new
+    config2.namespaced.persist(:avalue)
+    expect(config2.namespaced.avalue).to eq("Groovy!")
+  end
+  
+  it "allows for default values" do
+    # we have to make sure localStorage is nulled out here, otherwise
+    # the test will fail after the first time it's run :)
+    `window.localStorage.removeItem('config.somevalue')`
+    `window.localStorage.removeItem('config.othervalue')`
+  
+    config.persist_defaults do |c|
+      c.somevalue = "abc"
+      c.othervalue = 123
+    end
+    
+    expect(config.somevalue).to eq("abc")
+
+    config.somevalue = "xyz"    
+    expect(config.somevalue).to eq("xyz")
+    
+    config2 = Shimmer::Config.new
+    config2.persist_defaults do |c|
+      c.somevalue = "abc"
+      c.othervalue = 123
+    end
+    
+    expect(config2.somevalue).to eq("xyz")
+    expect(config2.othervalue).to eq(123)
+  end
+  
+  it "can delete a value" do
+    # we have to make sure localStorage is nulled out here, otherwise
+    # the test will fail after the first time it's run :)
+    `window.localStorage.removeItem('config.somevalue')`
+    `window.localStorage.removeItem('config.othervalue')`
+  
+    config.persist_defaults do |c|
+      c.somevalue = "abc"
+      c.othervalue = 123
+    end
+    
+    expect(config.somevalue).to eq("abc")
+
+    config.somevalue = "xyz"    
+    expect(config.somevalue).to eq("xyz")
+    
+    config.delete(:somevalue)
+    
+    config2 = Shimmer::Config.new
+    config2.persist_defaults do |c|
+      c.somevalue = "abc"
+      c.othervalue = 123
+    end
+    
+    expect(config2.somevalue).to eq("abc")
+    expect(config2.othervalue).to eq(123)
+  end 
+  
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: opal-shimmer
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Jared White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0.beta1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0.beta2
+description: An application state and configuration management library built with
+  Opal
+email:
+- jared@ealchemylabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config.ru
+- lib/opal-shimmer.rb
+- lib/opal/shimmer.rb
+- lib/opal/shimmer/version.rb
+- opal-shimmer.gemspec
+- opal/shimmer.rb
+- opal/shimmer/config.rb
+- opal/shimmer/storage.rb
+- spec/config_spec.rb
+- spec/spec_helper.rb
+- spec/storage_spec.rb
+homepage: https://github.com/jaredcwhite/opal-shimmer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: An application state and configuration management library built with Opal
+test_files:
+- spec/config_spec.rb
+- spec/spec_helper.rb
+- spec/storage_spec.rb