device_map 0.0.1 → 0.1.0

data/spec/classifier_spec.rb

@@ -0,0 +1,44 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::Classifier do
+  describe '#find_device' do
+    let(:user_agent) { 'test' }
+
+    let(:classifier) do
+      described_class.instance
+    end
+
+    let(:device) do
+      DeviceMap::DeviceData::Device.new(id: 'device_id')
+    end
+
+    context 'when device is found' do
+      before do
+        pattern = DeviceMap::Pattern.new(user_agent, device.id, 1)
+        expect(classifier.patterns).to receive(:find) do
+          Set.new [pattern]
+        end
+      end
+
+      it 'returns device object' do
+        expect(classifier.devices).to receive(:find).with(device.id) { device }
+
+        found_device = classifier.find_device(user_agent)
+        expect(found_device).to eq device
+      end
+    end
+
+    context 'when device is not found' do
+      before do
+        expect(classifier.patterns).to receive(:find) do
+          Set.new
+        end
+      end
+
+      it 'returns unknown device object' do
+        found_device = classifier.find_device(user_agent)
+        expect(found_device).to eq DeviceMap::DeviceData::Device.unknown
+      end
+    end
+  end
+end

data/spec/device_data/builder_spec.rb

@@ -0,0 +1,65 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::DeviceData::Builder do
+  let(:builder_node_class) { 'builder_node_class' }
+
+  let(:device_id) { 'device_id' }
+  let(:keywords) { ['keyword1', 'keyword2'] }
+
+  def builder
+    default_priority = 1
+    described_class.new(default_priority)
+  end
+
+  describe '.find' do
+    it 'returns builder object' do
+      builder_stub = double(:builder)
+      described_class.register(builder_stub, builder_node_class)
+
+      builder = described_class.find(builder_node_class)
+
+      expect(builder).to eq builder_stub
+    end
+
+    it 'raises exception if builder node class is unknown' do
+      expect do
+        described_class.find('unknown')
+      end.to raise_error(DeviceMap::DeviceData::Builder::BuilderNotFound)
+    end
+  end
+
+  describe DeviceMap::DeviceData::Builder::Simple do
+    before do
+      DeviceMap::DeviceData::Builder.register(
+        described_class, builder_node_class)
+    end
+
+    describe '#patterns' do
+      it 'maps single pattern object to each device keyword' do
+        patterns = builder.patterns(device_id, keywords)
+
+        expect(patterns.size).to eq keywords.size
+        pattern_keywords = patterns.flat_map(&:keywords)
+        expect(pattern_keywords).to eq keywords
+      end
+    end
+  end
+
+  describe DeviceMap::DeviceData::Builder::TwoStep do
+    before do
+      DeviceMap::DeviceData::Builder.register(
+        described_class, builder_node_class)
+    end
+
+    describe '#patterns' do
+      it 'maps all device keywords to single pattern object' do
+        patterns = builder.patterns(device_id, keywords)
+
+        expect(patterns.size).to eq 2
+        pattern_keywords = patterns.flat_map(&:keywords)
+        expect(pattern_keywords).to include(*keywords)
+        expect(pattern_keywords).to include(keywords.join)
+      end
+    end
+  end
+end

data/spec/device_data/device_spec.rb

@@ -0,0 +1,26 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::DeviceData::Device do
+  describe '.parse' do
+    it 'returns new instance of this class' do
+      properties = { id: 'iphone', vendor: 'Apple' }
+      device_node = generate_device_node(properties)
+      device = described_class.parse(device_node)
+
+      expect(device.id).to eq properties.fetch(:id)
+      expect(device.vendor).to eq properties.fetch(:vendor)
+    end
+
+    def generate_device_node(properties)
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.device(id: properties.fetch(:id)) do
+          properties.each do |name, value|
+            xml.property(name: name, value: value)
+          end
+        end
+      end
+
+      builder.doc.child
+    end
+  end
+end

data/spec/device_data/devices_spec.rb

@@ -0,0 +1,37 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::DeviceData::Devices do
+  describe '#find' do
+    it 'finds device by its id' do
+      device_stub = double(id: 'device_id')
+      devices = described_class.new(Array(device_stub))
+      device = devices.find(device_stub.id)
+      expect(device.id).to eq device_stub.id
+    end
+
+    it 'raises exception if device is not found' do
+      devices = described_class.new([])
+      expect do
+        devices.find('anything')
+      end.to raise_error(DeviceMap::DeviceData::Devices::DeviceNotFound)
+    end
+  end
+
+  describe '.parse' do
+    it 'returns new instance of this class' do
+      devices_xml = generate_devices_xml.to_xml
+      devices = described_class.parse(devices_xml)
+      expect(devices).to be_a(described_class)
+    end
+  end
+
+  def generate_devices_xml
+    Nokogiri::XML::Builder.new do |xml|
+      xml.ODDR do
+        xml.Devices do
+          xml.device
+        end
+      end
+    end
+  end
+end

data/spec/device_data/patterns_spec.rb

@@ -0,0 +1,52 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::DeviceData::Patterns do
+  let(:keyword) { 'keyword' }
+
+  let(:pattern) do
+    DeviceMap::Pattern.new(keyword, 'device_id', 1)
+  end
+
+  # FIXME: Bad specs
+  describe '.parse' do
+    it 'returns instance of patterns class' do
+      builder_stub = double(:builder, patterns: Array(pattern))
+      expect(DeviceMap::DeviceData::Builder).to receive(:find) { builder_stub }
+
+      openddr_builder = Nokogiri::XML::Builder.new do |xml|
+        xml.ODDR do
+          xml.Builders do
+            xml.builder do
+              xml.device do
+                xml.list do
+                  xml.value_ 'test'
+                end
+              end
+            end
+          end
+        end
+      end
+
+      patterns = described_class.parse(openddr_builder.to_xml)
+
+      expect(patterns).to be_a(described_class)
+      expect(patterns.find(keyword)).to include pattern
+    end
+  end
+
+  describe '#find' do
+    it 'returns list of patterns for the given keyword' do
+      patterns = described_class.new(Array(pattern))
+      search_results = patterns.find(keyword)
+
+      expect(search_results).to include pattern
+    end
+
+    it 'returns empty list if keyword is not found' do
+      all_patterns = []
+      patterns = described_class.new(all_patterns)
+      devices = patterns.find('anything')
+      expect(devices).to be_empty
+    end
+  end
+end

data/spec/device_map_spec.rb

@@ -0,0 +1,10 @@
+require 'device_map'
+
+RSpec.describe DeviceMap do
+  describe '.classify' do
+    it 'returns device' do
+      device = described_class.classify('android')
+      expect(device).to be_a(DeviceMap::DeviceData::Device)
+    end
+  end
+end

data/spec/keyword_spec.rb

@@ -0,0 +1,32 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::Keyword do
+  describe '.normalize' do
+    it 'strips all non-alphanumeric characters' do
+      normalized_keywords = described_class.normalize ['test-123', 'test_123']
+      expect(normalized_keywords).to eq ['test123', 'test123']
+    end
+
+    it 'convers all characters to lower case' do
+      normalized_keywords = described_class.normalize ['Test', 'TEST']
+      expect(normalized_keywords).to eq ['test', 'test']
+    end
+
+    example do
+      normalized_keywords = described_class.normalize ['[Bb]lack.?[Bb]erry']
+      expect(normalized_keywords).to eq ['blackberry']
+    end
+  end
+
+  describe '.join' do
+    example do
+      joined_keywords = described_class.join ['test', '123']
+      expect(joined_keywords).to eq 'test123'
+    end
+
+    example do
+      joined_keywords = described_class.join ['test', 'test123']
+      expect(joined_keywords).to eq 'test123'
+    end
+  end
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,49 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::Pattern do
+  let(:priority) { 1 }
+  let(:higher_priority) { priority + 1 }
+
+  let(:keyword) { 'keyword' }
+  let(:longer_keyword) { 'longer_keyword' }
+
+  let(:device_id) { 'device_id' }
+
+  it 'is comparable by keyword size' do
+    pattern1 = described_class.new(keyword, device_id, priority)
+    pattern2 = described_class.new(longer_keyword, device_id, priority)
+
+    expect(pattern1).to be < pattern2
+  end
+
+  it 'is comparable by priority' do
+    pattern1 = described_class.new(keyword, device_id, higher_priority)
+    pattern2 = described_class.new(longer_keyword, device_id, priority)
+
+    expect(pattern1).to be > pattern2
+  end
+
+  it 'can be equal to other pattern' do
+    pattern1 = described_class.new(keyword, device_id, priority)
+    pattern2 = described_class.new(keyword, device_id, priority)
+
+    expect(pattern1).to eq pattern2
+  end
+
+  describe '#matches?' do
+    let(:pattern) do
+      described_class.new(keyword, device_id, priority)
+    end
+
+    let(:other_keywords) { ['anything', 'else'] }
+
+    it 'returns true if given keywords contain all pattern keywords' do
+      given_keywords = other_keywords + pattern.keywords
+      expect(pattern.matches?(given_keywords)).to eq true
+    end
+
+    it 'returns false if given keywords do not contain all pattern keywords' do
+      expect(pattern.matches?(other_keywords)).to eq false
+    end
+  end
+end

data/spec/properties/dsl_spec.rb

@@ -0,0 +1,61 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::Properties::DSL do
+  describe '.property' do
+    let(:model) do
+      Class.new do
+        include DeviceMap::Properties::DSL
+      end
+    end
+
+    it 'defines class attribute' do
+      property_value = 'test'
+      model.property :property
+      model_instance = model.new('property' => property_value)
+
+      expect(model_instance.property).to eq property_value
+    end
+
+    it 'allows to change attribute name' do
+      property_value = 'test'
+      model.property :property, attr_name: :other_property
+      model_instance = model.new('property' => property_value)
+      expect(model_instance.other_property).to eq property_value
+    end
+
+    it 'can cast property value to integer' do
+      model.property :property, type: :integer
+      model_instance = model.new('property' => '8')
+      expect(model_instance.property).to eq 8
+    end
+
+    it 'can cast property value to boolean' do
+      model.property :property, type: :boolean
+      model_instance = model.new('property' => 'false')
+      expect(model_instance.property).to eq false
+    end
+
+    it 'raises exception during initialization if given param is unknown' do
+      expect do
+        model.new('unknown_param' => 'value')
+      end.to raise_error(DeviceMap::Properties::UnknownProperty)
+    end
+
+    it 'is equal to other object if it has the same properties' do
+      property_value = 'test'
+      model.property :property
+      model_instance1 = model.new('property' => property_value)
+      model_instance2 = model.new('property' => property_value)
+
+      expect(model_instance1).to eq model_instance2
+    end
+
+    it 'is not equal to other object if it has different properties' do
+      model.property :property
+      model_instance1 = model.new('property' => 'test1')
+      model_instance2 = model.new('property' => 'test2')
+
+      expect(model_instance1).not_to eq model_instance2
+    end
+  end
+end

data/spec/user_agent_spec.rb

@@ -0,0 +1,46 @@
+require 'device_map'
+
+RSpec.describe DeviceMap::UserAgent do
+  describe '#keyword_ngrams' do
+    example do
+      user_agent = described_class.new('iphone')
+      ngrams = user_agent.keyword_ngrams(1)
+
+      expect(ngrams.size).to eq 1
+      expect(ngrams).to include ['iphone']
+    end
+
+    example do
+      user_agent = described_class.new('iPhone; U')
+      ngrams = user_agent.keyword_ngrams(2)
+
+      expect(ngrams.size).to eq 3
+      expect(ngrams).to include ['iphone']
+      expect(ngrams).to include ['iphone', 'u']
+      expect(ngrams).to include ['u']
+    end
+
+    example do
+      user_agent = described_class.new('Mozilla/5.0')
+      ngrams = user_agent.keyword_ngrams(3)
+
+      expect(ngrams.size).to eq 3
+      expect(ngrams).to include ['mozilla']
+      expect(ngrams).to include ['mozilla', '50']
+      expect(ngrams).to include ['50']
+    end
+
+    example do
+      user_agent = described_class.new('Mozilla/5.0 (iPhone)')
+      ngrams = user_agent.keyword_ngrams(3)
+
+      expect(ngrams.size).to eq 6
+      expect(ngrams).to include ['mozilla']
+      expect(ngrams).to include ['mozilla', '50']
+      expect(ngrams).to include ['mozilla', '50', 'iphone']
+      expect(ngrams).to include ['50']
+      expect(ngrams).to include ['50', 'iphone']
+      expect(ngrams).to include ['iphone']
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: device_map
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Konstantin Papkovskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-21 00:00:00.000000000 Z
+date: 2015-01-17 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,22 +52,97 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Ruby client for Apache DeviceMap
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+description: |2
+      Ruby implementation of client for Apache DeviceMap repository
+      containing device information, images and other relevant
+      information for all sorts of mobile devices.
 email:
 - konstantin@papkovskiy.com
 executables: []
-extensions: []
+extensions:
+- ext/Rakefile
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
+- README.md
+- Rakefile
 - device_map.gemspec
+- ext/Rakefile
 - lib/device_map.rb
+- lib/device_map/classifier.rb
+- lib/device_map/device_data/builder.rb
+- lib/device_map/device_data/device.rb
+- lib/device_map/device_data/devices.rb
+- lib/device_map/device_data/patterns.rb
+- lib/device_map/keyword.rb
+- lib/device_map/pattern.rb
+- lib/device_map/properties/dsl.rb
+- lib/device_map/properties/property.rb
+- lib/device_map/properties/types.rb
+- lib/device_map/user_agent.rb
 - lib/device_map/version.rb
-homepage: ''
+- lib/resources/BuilderDataSource.xml
+- lib/resources/DeviceDataSource.xml
+- spec/classifier_spec.rb
+- spec/device_data/builder_spec.rb
+- spec/device_data/device_spec.rb
+- spec/device_data/devices_spec.rb
+- spec/device_data/patterns_spec.rb
+- spec/device_map_spec.rb
+- spec/keyword_spec.rb
+- spec/pattern_spec.rb
+- spec/properties/dsl_spec.rb
+- spec/user_agent_spec.rb
+homepage: https://github.com/soylent/device_map
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -71,8 +160,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby client for Apache DeviceMap
-test_files: []
+test_files:
+- spec/classifier_spec.rb
+- spec/device_data/builder_spec.rb
+- spec/device_data/device_spec.rb
+- spec/device_data/devices_spec.rb
+- spec/device_data/patterns_spec.rb
+- spec/device_map_spec.rb
+- spec/keyword_spec.rb
+- spec/pattern_spec.rb
+- spec/properties/dsl_spec.rb
+- spec/user_agent_spec.rb